﻿//#include "game.h"
#define _CRT_SECURE_NO_WARNINGS 1//scanf strncpy strncat
#include <stdlib.h>//system //qsort //malloc
#include <stddef.h> //offsefof
#include <math.h>//平方根 pow
#include <stdbool.h>//bool  //光标不可见
#include <stdio.h>//return 0
#include <time.h>// 随机数
#include <windows.h>//Sleep  COORD
//#define NDEDUG//禁止下一条语句
#include <assert.h>//assert 断言
//#include<iostream>//c++   //.c文件中不可用这句话 c++文件可以写c的代码 反过来不可以
#include <ctype.h>
#include <errno.h>//errno
#include <stddef.h>//offsefof
#include <locale.h>//宽字节
//12805 贪吃蛇

//int main()
//{
//	printf("hello world\n");
//
//
//
//
//	return 0;
//}

//
//int main()
//{
//
//	printf("%s\n", "hello");
//
//
//
//
//	return 0;
//}
//



//字符串""
//单字符''
//整数d
//小数f(float)
//字符c













///b=b+1    b+=1      b++




//int main()
//{
//	bool a = true;
//	if (a)
//		printf("hh\n");
//	printf("%zd\n", sizeof(int));
//	long s = 10;
//	int b = 5;;
//	printf("%zd\n", sizeof(s = b + 1));
//
//	
//		printf(" % d\n", 11 + 22);
//
//

//		return 0;
//}











//int main()
//{
//	int a = 1;
//	int b = 0;//--a叫先减法再使用 反之成立
//	b = a--;
//
//		printf("%d\n", a);
//		printf("%d\n",b);
//		printf("%d\n", a);
//
//	return 0;
//
//}
//
//int main()
//{
//	printf("%f\n", 3.14);
//
//	printf(" %c will come", 'p');
//
//	return 0;
//}

//int main()
//{
//	printf("%2hd\n", 15);
//
//	printf("%12lf\n", 100.45);
//	printf("%7.1lf\n", 100.11);
//	printf("%*.*lf", 12, 1, 400.12);
//

//
//int main()
//{
//	int score = 0;
//	printf("请输入成绩:");
//	scanf("%d", &score);
//	printf("成绩是：%d\n", score);
//	return 0;
//
//
//}


//
//int main()
//{
//	int score = 0;
//	
//	scanf("%d", &score);
//	printf("成绩是：%d\n", score);
//	return 0;
//
//
//}

//int main()
//{
//	int a = 5;
//	int b = 10;//先赋值，scanf
//	float f4 = 6.2;
//	float f3 = 2.3;
//	scanf("%d %d %f %f", &a ,&b,&f4,&f3);
//	printf("%d %d %f %12.1f", a,b,f4,f3);
//	return 0;
//}

//int main()
//{
//	int weight = 0;
//	printf("体重的大小是多少?回答:");//printf是一种打印
// 
//		scanf("%d", &weight);
//	printf("体重是%d", weight);//scanf是一种手动的输出,要用&
//
//
//
//	return 0;
//}

//
//int main()
//{
//	int a;
//		float b = 5.2;
//		scanf("%d", &a);
//		printf("%d\n", a);//科学计数法e指的是10的几次方
//		
//		
//		//当输入13.45e12#时
//		//读整数会将13读走之后是小数点会停下 
//		//由浮点数来读取.45e12    到#号会停止
//		//scanf读取数据时
//		// 不读空格,按所写代码读取,
//		//浮点数不够精确会有误差
//
//		scanf("%f", &b);
//		printf("%f", b);
//
//
// 
// 
// //放到一行也可以 
// 参考150行
//
//	return 0;
//}


//int  main()
//{
//	int a = 5;
//	float b = 2.2;
//	scanf("%d %f",&a,&b);
//	printf("%d %f",a,b);
//
//
//
//	return 0;



//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	int d = 0;
//	int ret =scanf("%d %d %d %d", &a, &b, &c, &d);//ret指的是返回值
//	printf("a=%d b=%d c=%d d=%d\n", a, b, c, d);
//	printf("ret=%d", ret);
//
//
//
//
//
//
//
//
//	return 0;
//}



//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	int d = 0;
//	int ret = scanf("%d %d %d %d", &a, &b, &c, &d);//ret指的是返回值
//	printf("a=%d b=%d c=%d d=%d\n", a, b, c, d);
//	printf("ret=%d", ret);
//
//
//
//
//
//
//
//
//	return 0;
//}
//
//int main()
//{
//	char arr[20] = { 0 };
//	scanf("%s", arr);//arr是数组名，数组名本身就是地址
//	printf("%s", arr);
//
//
//
//	return 0;
//}
//
//
//
//
//
//
////%c不会跳过空格 如果想跳过可以输入% c

//
//
//int main()
//{
//	int year = 0;
//	int month = 0;
//	int day = 0;
//	scanf("%d-%d-%d", &year, &month, &day);
//	printf("%d %d %d", year, month, day);
//	return 0;
//}


//int main()
//{
//	int year = 0;
//	int month = 0;
//	int day = 0;
//	scanf("%d%*c%d%*c%d", &year, &month, &day);//%*c赋值忽略符
//	printf("%d %d %d", year, month, day);
//	return 0;
//}


//作业1//#include <stdio.h>
//
//int main() {
//    int a, b;
//    while (scanf("%d %d", &a, &b) != EOF) { // 注意 while 处理多个 case
//        // 64 位输出请用 printf("%lld") to 
//        printf("%d %d", a / b, a % b);
//    }
//    return 0;
//}




//#include <stdio.h>
//
//int main()
//
//{
//    int b = 0;
//    while (scanf("%d", &b) != EOF) { // 注意 while 处理多个 case//你是天才吗作业
//        // 64 位输出请用 printf("%lld") to
//
//        if (b >= 140)
//
//            printf("Genius");
//    }
//    return 0;
//}



//
//int main()
//{
//	char arr[20] = { 0 };
//	scanf("%s", arr);//arr是数组名，数组名本身就是地址
//	if (arr )
//		printf ("%d",250);
//
//
//	return 0;
//}
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	if (num % 2 == 1)
//		printf("%d是奇数",num);//等于为==
//
//	return 0;
//}

//
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	if (num % 2 == 1)
//		printf("%d是奇数", num);//else是
//	else
//		printf("%d是偶数", num);
//
//
//	return 0;
//}
//
//输入一个年龄,大于18就成年,没大于就没成年
//int main()
//{
//	int age = 0;
//	scanf("%d", &age);
//	if (age >= 18)
//		printf("成年");
//	else
//		printf("未成年");
//	return 0;
//}

//
//
// int main()
//{
//	int age = 0;
//	scanf("%d", &age);//当if下有多个语句是要用{} else也要用{}
//	if (age >= 18)
//	{
//		printf("成年\n");
//		printf("可以谈恋爱了");
//	}
//	else
//		printf("未成年");
//	return 0;
//}
//
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	if (num > 0)
//		printf("输入的值是正数");
//	else
//	{
//		if (num == 0)
//			printf("输入的值是0");
//		if (num < 0)
//			printf("输入的值是负数");
//	}
//	return 0;
//}

//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	if (num >= 0)
//		printf("输入的值是非负数");
//	else
//	{
//			printf("输入的值是负数");//else下若有多个判断,仍可以使用if
//	}
//	return 0;
//}
//int main()
//{
//	int num = 0;
//	scanf("%d", &num);
//	if (num > 0)
//		printf("输入的值是正数");
//	else
//	{
//		if (num == 0)
//			printf("输入的值是0");//else下仍可以使用else去嵌套
//		else
//			printf("输入的值是负数");
//	}
//	return 0;
//}


//
//
//int main()
//{
//	int age = 0;
//	scanf("%d", &age);
//	if (age < 18)
//		printf("少年");
//	else if (age <= 44)
//		printf("青年");
//	else if (age <= 59)
//		printf("中老年");
//	else if (age <= 89)
//		printf("老年");
//	else printf("老毕登");
//	return 0;
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    int c = 0;
//    int d = 0;
//    int e = 0;
//    int f = 0;
//    scanf("%d %d", &a, &b);
//    if (a == b)
//        printf("%d=%d\n", a, b);
//    else if (a < b)
//        printf("%d<%d\n", a, b);//不过的原因是没写while循环无法进行多组数
//    else printf("%d>%d\n", a, b);
//
//
	//scanf("%d %d", &c, &d);
	//if (c == d)
	//    printf("%d=%d\n", c, d);
	//else if (c < d)
	//    printf("%d<%d\n", c, d);
	//else printf("%d>%d\n", c, d);


	//scanf("%d %d", &e, &f);
	//if (e == f)
	//    printf("%d=%d\n", e, f);
	//else if (e < f)
	//    printf("%d<%d\n", e, f);
	//else printf("%d>%d\n", e, f);

//
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);//被五整除问题
//    if (a % 5 == 0)
//        printf("YES");
//    else
//        printf("NO");
//    return 0;
//}
//int main() 
//
//{
//    int i, n;
//    scanf("%d", &n);//提前照抄,
//    {
//        for (i = 1; i <= n; i++) {
//            printf("*");
//
//        }
//        printf("\n");
//    }
//}

//int main()
//{
//	char arr[20] = { 5 };
//	scanf("%s", arr);//整蛊没学过计算机的朋友小妙招
//	if (arr)
//		printf("张生达");
//	return 0;
//}

//
//int main()
//{
//    int a;
//    int b;
//    scanf("%d %d", &a, &b);
//    if (a == b)
//        printf("%d=%d\n", a, b);
//    else if (a < b)
//        printf("%d<%d\n", a, b);
//    else printf("%d>%d\n", a, b);
//
//
//
//
//    return 0;
//}
//c语言中相等为==
// a和b相等即是a==b
//不相等即是!=


//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d %d", &a, &b)
//    if (a != b)
//        printf("hehe\n");
//    return 0;
//}

//
//int main()
//{
//    int a = (3 == 5);;//0为假的，1为真的
//    printf("%d", a);
//
//
//    return 0;//此代码输入结果为0
//}


//当一个变量和一个常亮相等的时候，建议将常量写在==的左边
//如下文
//int main()
//{
//    int a = 5;
//        if (5 == a)//此处如果输入5=a则无法运行
//          printf("hh");
//
//
//
//    return 0;
//}
//&&符号为并且 
//if (a=b&&b=c)
//因为当写if (a=b=c）时
// 代码会优先执行a=b   如果命题为真那么此时为1=c，不是想要的结果，用上面的
//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d",&a);
//    if (a > 5)
//        b = 3;
//    else
//        b = 2;
//
//    printf("b=%d", b);
//
//    return 0;//也可以更简便的写
// 
//}
//用三目操作符
	 //        ?    :
	 // 以上代码可以简化成
//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d",&a);
//    b = (a > 5 ? 3: 2);//此时若a>5执行3      若a<5则执行2
//    printf("b=%d",b);
//    return 0;
//}
//
//int main()
//{
//    int month = 0;
//    scanf("%d", &month);
//    if (month > 3 && month < 5)
//        printf("春季");
//
//    return 0;//&&为并且，一假则假；||为或者，一真则真
//}
//int main()
//{
//    int month = 0;
//    scanf("%d", &month);
//    if (month == 12 || month == 1 || month == 2)
//        printf("冬季");
//
//    return 0;
//}
//

//int main()
//{
//    int a = 4;
//    scanf("%d", &a);
//    if (a % 3 == 1)
//        printf("%d除以三的余数是1", a);
//    else if (a % 3 == 2)
//        printf("%d除以三的余数是2", a);
//    else printf("%d除以三的余数是0",a);
//
//    return 0;//if语句情况下
// 
// 
//}
//
//int main()
//{
//    int a = 2;
//    scanf("%d", &a);
//    switch (a % 3)
//    {
//    case 0:
//        printf("除以三的余数是0");
//        break;
//    case 1:
//        printf("除以三的余数是1");
//        break;
//    case 2:
//        printf("除以三的余数是2");//switch表达式必须为整形，也可以使用char类型 因为字符类型本身就属于整型类型
//        break;






//
//    }
//
//
//
//    return 0;
//}
//int main()
//{
//    int a = 4;
//    scanf("%d", &a);
//    switch (a)
//    {
//    case 1:
//        printf("我我我我");
//        break;
//    case 2:
//        printf("你你你你");
//        break;
//    default:
//            printf("00000000");
//            break;
//    
//    
//    }
//      return 0;
//}
//int main()
//{
//    int a = 5;
//    while (a > 0)
//        printf("666");//while是一种循环
//
//    return 0;
//}
//int main()
//{
//    int a = 1;
//    while (a <=10)
//    {
//        printf("%d ", a);
//        a++;
//    }
//    return 0;
//}
//int main()
//{
//    int a = 0; 
//    scanf("%d", &a);
//    while(a)
//    { 
//        printf("%d ", a % 10);
//        a = a / 10;
//    
//    
//    
//    }
//
//    return 0;


//int main()
//{
//    int a = 1;
//    while (a <=10)
//    {
//        printf("%d ", a);
//        a++;
//    }
//    return 0;//也可以用for循环来写
//
//
////}
//int main()
//{
//    int a = 1;
//    for (a = 1; a < 11; a++)
//    {
//        printf("%d ", a);
//    }
//    return 0;
//}
//计算一到100之间3的倍数之和
//int main()
//{
//
//    int a = 1;
//    int sum = 0;
//    for (a = 3; a <= 100; a += 3)
//    {
//
//        sum = sum + a;
//        printf("%d", sum);
//    }
//
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    int sum = 0;
//    for (a = 1 ; a <= 100 ; a++)
//    {
//        if (a % 3 == 0)
//            sum += a;
//        
//    }
//    printf("%d", sum);
//    return 0;
//
//}
// int main()
// {
//int a = 1;
//    int sum = 0;
//    for (a = 3; a <= 100; a += 3)
//    {
//
//        sum = sum + a;
//       
//    }
//    printf("%d", sum);//
//    return 0;
//}
//使用do while来打印1到10的值
//int main()
//{
//    int a = 1;
//    do
//    {
//        printf("%d ", a);
//        a++;
//    }  
//    while (a <= 10);
//    return 0;
//}
////输入一个正整数，计算这个整数是几位数
//int main()
//{
//    int a = 1;
//    int count = 0;
//    scanf("%d", &a);
//    do
//    {
//        a = a / 10;
//        count++;//count表示位数
//
//    } while (a);
//    printf("%d", count);
//
//
//    return 0;
//}
//int main()
//{
//    int a = 1;
//    for (a = 1; a < 11; a++)
//    {
//        
//        if (a == 5)
//            break;
//           printf("%d ", a);
//          
//    }
//    return 0;
//}
//int main()
//{
//    int a = 1;
//    for (a = 1; a < 11; a++)
//    {
//
//        if (a == 5)
//            continue;
//        printf("%d ", a);
//
//    }
//    return 0;
//}
//#include<stdio.h>
//#define Height 10
//int calculate(int Long, int Width);
//int main()
//{
//    int m_Long;
//    int m_Width;
//    int result;
//
//    printf("长方形的高度为:%d\n", Height);
//
//    printf("请输入长度\n");
//    scanf("%d", &m_Long);
//
//    printf("请输入宽度\n");
//    scanf("%d", &m_Width);
//
//    result = calculate(m_Long, m_Width);
//    printf("长方形体积是：");
//    printf("%d\n", result);
//    return 0;
//}
//
//int calculate(int Long, int Width)
//{
//    int result = Long * Width * Height;
//    return result;
//}
//int main()
//{
//    int a = 0 ;
//    while (a <= 10)
//    {
//        a++;
//        if (a == 5)
//            continue;
//
//        printf("%d ", a);
//    }
//    return 0;
//}
//int main()
//{
//    int a = 1;
//    while (a <= 10)
//    {
//        
//        if (a == 5)
//            continue;
//
//        printf("%d ", a);//此处会进行死循环
//        a++;
//    }
//    return 0;
//}

//找出一百到二百以内的素数，打印在屏幕上
//
//int main()
//{
//    int a = 0;
//    int b = 2;
//
//    for (a = 100; a <= 200; a++)
//
//    {
//        int flag = 1;
//        int b = 2;
//        for (b = 2; b <= a - 1; b++
//    )
//        {
//
//            if (a % b == 0)
//            {
//                flag = 2;
//                break;
//            }
//
//
//        }
//        if (flag == 1)
//        {
//            printf("%d", a);
//        }
//        }
//
//
//    return 0;
//}

////找出一百到二百以内的素数，打印在屏幕上
//int main()
//{
//    int a = 0;
//    int b = 0;
//    for (a = 100; a <= 200; a++)
//    {
//        int flag = 1;
//        for (b = 2; b <= a - 1; b++)
//        {
//            if (a % b == 0)
//            {
//                flag = 0;
//                break;
//            }
//
//         }
//
//        if (flag == 1)
//        {
//            printf("%d ", a);
//        }
//    }
//
//
//
//    return 0;
//}
//
//int main()
//{
//    int a = 0;
//    int b = 2;
//    int count = 0;
//    for (a = 100; a <= 200; a+=2)
//
//    {
//        int flag = 1;
//        
//        for (b = 2; b <= sqrt(a); b++)
//
//        {
//
//            if (a % b == 0)
//            {
//                flag = 2;//sqrt是一个库函数，用来取平方根的      math.h
//                break;
//            }
//
//
//        }
//        if (flag == 1)
//        {
//
//            printf("%d ", a);
//
//        }
//    }
//   
//    
//    return 0;
//}
//
//int main()
//{
//    int a = 0;
//    int b = 0;
//    for (a = 100; a <= 200; a++)
//    {
//        int flag = 1;
//        for (b = 2; b <= a - 1; b++)
//        {
//            if (a % b == 0)
//            {
//                flag = 0;
//                break;
//            }
//
//         }
//
//        if (flag == 1)
//        {
//            printf("%d ", a);
//        }
//    }
//
//
//
//    return 0;
//}
//
//int main()
//{
//    int a = 0;
//    int b = 2;
//    int count = 0;
//    for (a = 100; a <= 200; a++)
//
//    {
//        int flag = 1; 
//        for (b = 2; b <= sqrt(a); b++)
//
//        {
//
//            if (a % b == 0)
//            {
//                flag = 2;//sqrt是一个库函数，用来取平方根的      math.h
//                break;
//            }
//
//
//        }
//        if (flag == 1)
//        {
//            count++;
//            printf("%d\n ", a);
//
//        }
//    }
//    printf("%d\n", count);
//    
////    return 0;
//int main()
//{
//    printf("%d", 100);
//    return 0;
//}

/*nt main()
{
	end:
	printf("hehe");
	goto end;

	return 0;
}*/

////-s关机 -t设置时间关机
//shutdown -s -t 60//还有60秒关机
//shutdown -a取消关机
//system 库函数,可以执行系统命令,stdlib.h
#include <string.h>//strcmp
//
//int main()
//{
//    char input[20] = { 0 };
//    system("shutdown -s -t 60");
//again:
//    printf("请注意，你的电脑将在1分钟内关机，输入我是猪就取消关机");
//    scanf("%s", input);
//    if( strcmp("我是猪", input) == 0)
//    {
//        system("shutdown -a");
//        }
//       else
//       {
//           goto again;
//       }
//
//       return 0;
//       
//}
//
//int main()
//{
//    
//    printf("%d\n", rand());
//    printf("%d\n", rand());
//    printf("%d\n", rand());//rand函数是伪随机的，下一次和上一次的值相等
//        printf("%d\n", rand());
//      
//
//    return 0;
////}
//int main()
//{
//    srand((unsigned int)time(NULL));//设置随机数的生成起点，种子
//    printf("%d\n", rand());
//        printf("%d\n", rand());
//        printf("%d\n", rand());
//    return 0;
//}

//int main()
//{
//    int c = 0;
//    int count = 10;
//    char input[20] = { 0 };
//    
//    printf("欢迎来到猜数字游戏，输入1开始游戏，输入0退出游戏\n");
//again:
//    scanf("%d", &c);
//    if (c == 1)
//    {
//        printf("游戏开始,你一共有十次机会\n");
//        srand((unsigned int)time(NULL));
//        int a = rand() % 100 + 1;
//        int b = 0;
//
//    end:
//        if (count == 0)
//        {
//            printf("很抱歉，你的次数用尽了，输入我是猪，可以增加5次机会，如果不，请退出游戏\n");
//            scanf("%s", input);
//            if (strcmp("我是猪", input) == 0)
//            {
//                count = 5;
//                goto end;
//            }
//
//            else
//            {
//                printf("游戏结束");
//                goto ending;
//            }
//        }
//        scanf("%d", &b);
//        if (b > a)
//        {
//            printf("你猜大了\n");
//            count--;
//            printf("你还有%d次机会\n", count);
//            goto end;
//        }
//        else if (b < a)
//        {
//            printf("你猜小了\n");
//            count--;
//            printf("你还有%d次机会\n", count);
//            goto end;
//        }
//        else (b == a);
//        printf("你答对了\n");
//        printf("是否继续玩游戏，1继续，0退出\n");//猜数字游戏
//        goto again;
//    }
//    else if (c == 0)
//    {
//        printf("欢迎下次玩游戏");
//    }
//    else (c != 0 && c != 1);
//    {
//        printf("输入错误，请重新输入数字\n");
//        goto again;
//    }
//    ending:
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    int c = 0;
//    scanf("%d %d %d", &a, &b, &c);
//    if (a < b)
//    {
//        int d = a;//将a和b的值对调，借助中间变量，其余比大小同理
//        a = b;
//        b = d;
//    }
//    printf("%d %d", a, b);
//    return 0;
//}
//#include <stdio.h>
//
//int main()
//{
//    int n = 0;
//    //多组输入
//    while (~scanf(" %d", &n))
//    {
//        for (int i = 1;i <= n; i++)
//        {
//            printf("*");
//        }
//        printf("\n");
//    }
//
//    return 0;/线段图案
//}
//使用switch语句时一定要注意case下要跟着break;否则会全部执行
//int main()
//{
//    int a = 1;
//    for (; a <= 9; a++)
//    {
//        int b = 1;
//        for (; b <= a; b++);
//        {
//            printf("%d*%d=%d", a, b, a * b);
//        }
//        printf("\n");
//    }
//    return 0;
//}
//#include<stdio.h>
//int main() {//第一种
//    int i = 0;
//    for (i = 1; i <= 9; i++) {
//        int j = 1;
//        for (j = 1; j <= i; j++) {
//            printf("%d*%d=%d", i, j, i * j);
//        }
//        printf("\n");
//    }
//}
//int main(){
//
//    int i = 0;
//    for (i = 1; i <= 9; i++)
//    {
//        int j = 1;
//        for (j = 1; j <= i; j++)
//        {
//            printf("%d*%d=%d ", i,j,i*j);//打印99乘法表，注意for循环后面不可加；
//        }
//        printf("\n");
//    }
//    return 0;
//
//}
//打印10个数中最大的数
//int main()
//{
//    int arr[10] = { 1,15,2255,15,155,11,2,111,2,2 };
//    int max = arr[0];
//    for (int i = 1; i <= 10; i++)
//    {
//        if (max < arr[i])
//        {
//            max = arr[i];
//        }
//    }
//    printf("%d", max);
//
//    return 0;
//}
//int main()
//{
//    int flag = 1;
//    double sum = 0.0;
//    
//    for ( int a = 1; a <= 100; a++)
//    {
//        sum = sum + 1.0 / a*flag;
//        flag = -flag;
//    }
//    printf("%lf", sum);
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    int count = 0;
//    for (a = 1; a <= 100; a++)
//    {
//        if (a % 10 == 9 || a / 10 == 9)
//        {
//            count++;
//            if (a % 10 == 9 && a / 10 == 9)
//                count++;
//        }
//    }
//    printf("%d", count);//一到一百有多少个整数9
//    return 0;
//}
//打印100到200之间的素数
//int main()
//{
//    int a = 0;
//    for (a = 100; a <= 200; a++)
//    {
//        int flag = 0;
//        for (int b = 2; b <= a - 1; b++)
//        {
//            
//            if (a % b == 0)
//            {
//                flag = 1;
//                break;
//            }
//        }
//        if (flag == 0);
//        {
//            printf("%d ", a);
//        }
//    }
//
//    return 0;
//}


//int main()
//{
//    int a = 0;
//    int b = 0;
//    for (a = 100; a <= 200; a++)
//    {
//        int flag = 1;
//        for (b = 2; b <= a - 1; b++)
//        {
//            if (a % b == 0)
//            {
//                flag = 0;
//                break;
//            }
//
//         }
//
//        if (flag == 1)
//        {
//            printf("%d ", a);
//        }
//    }
//
//int main()
//{
//    int math[] = { 0,1,11,1,1,1,1,1,1,1111 };
// 
//    for (int i = 0; i <= 9; i++)
//    {
//        printf("%d " ,math[i] );
//
//    }
//
//
//    return 0;
//}
//一堆数组在内存中的存储
////打印10个元素的地址加上取地址符号&
//%d 整型
//%c 字符
//%s 字符串
//%p 地址
// int main()
//{
//    int math[] = { 0,1,11,1,1,1,1,1,1,1111 };
// 
//    for (int i = 0; i <= 9; i++)
//    {
//        printf("&arr[%d]=%p\n",i ,&math[i] );
//
//    }
//
//
//    return 0;//16进制的数组 
//    //0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
//    //                     a  b  c  d  e  f
//    //                     A  B  C  D  E  F
//}//一个int类型的值占有4个字节
//数组在内存中是连续存放的，由低到高；
//
//
//int main()
//
//{
//    int i, n;
//    end:
//    scanf("%d", &n);//提前照抄,
//    {
//        for (i = 1; i <= n; i++) {
//            printf("*");
//
//        }
//        printf("\n");
//        goto end;
//    }
//}
//C99之前，数组在创建的时候，数组大小的制定只能使用常量
//C99之后,引入了变长数组的概念,使得数组的大小可以使用变量来指定;
//VS2022不支持
#include <windows.h>
//int main()
//{
//    char arr1[] = { "hello world" };
//    char arr2[] = { "###########" };
//    int left = 0;
//    int right = strlen(arr2) - 1;//strlen测量字符串的长度//string.h
//    while (left<=right)
//    {
//        arr2[left] = arr1[left];
//        arr2[right] = arr1[right];
//        printf("%s\n", arr2);
//        Sleep(1000);//休眠1000ms//windows.h
//        system("cls");//清理控制台屏幕的信息
//        left++;
//        right--;
//    }
//    printf("%s", arr2);
//    return 0;
//}
//int main()
//{
//    int arr[] = { 1,2,3,4,5,6,7,8,9,10};//0 1 2 3 4 5 6 7 8 9
//    int k = 0;
//    scanf("%d", &k);
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    int right = sz-1;
//    int left = 0;
//    
//    while (left <= right)
//    {
//        int mid = (left + right) / 2;//此处用mid=left+（left-right)/2更好,因为数组中数字有最大值,第一种方式有可能会出问题
//        if (arr[mid] < k)
//        {
//            left = mid + 1;
//
//        }
//        else if (arr[mid] > k)
//        {
//            right = mid - 1;
//
//        }
//        else
//        {
//            printf("找到了，下标是%d\n", mid);
//            break;
//
//        }
//    }
//    if (left > right)
//    {
//        printf("找不到%d\n", k);
//    }
//    return 0;
//}
//int main()
//{
//    int a = INT_MAX;//2147483647
////    printf("%d", a);
////    return 0;
////}
//int main()
//{
//    char acX[] = "abcdefg";
//    char acY[] = { 'a','b','c','d','e','f','g' };
//    int a = strlen(acX);
//    int b = strlen(acY);
//    printf("%d %d", a, b);
//    return 0;
//}
#/*include <stdio.h>
int main()
{
	char str[] = "hello bit";
	printf("%d %d\n", sizeof(str), strlen(str));//strlen不包括/0,sizeof包括/0
	return 0;                                     字符串          数组
}*/
//int main()
//{
//    int a = 0;
//   
//    for (; a <= 9; a++)
//    {
//        int b = 0;
//        for (; b <= a; b++)
//        {
//            printf("%d*%d=%d ", a, b, a * b);
//
//        }
//        printf("\n");
//    }
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    for (a = 1000; a <= 2000; a++)
//    {
//        int flag = 1;
//        int b = 2;
//        for (; b <= a - 1; b++)
//        {
//            if (a % b == 0)
//            {
//                flag = 0;
//                break;
//            }
//        }
//        if (flag==1)
//        {
//            printf("%d ", a);
//        }
//    }
//
//
//    return 0;
//}
// 
//int main()
//{
//  
//    int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
//    int b = 0;
//    for (; b <= 9; b++)
//    {
//        printf("%d ", a[b]);
//   }
//
//
//    return 0;
//}
//#include <stdio.h>
//int main()
//{
//    int arr[] = { 1,2,(3,4),5 };
//    printf("%d\n", sizeof(arr));
//    return 0;
//}
//0 1 2 3 4 
//1
//2
//3
//4
//
//int main()
//{
//    int a = 0;
//    a = 1, a + 5, a++;//逗号表达式只执行最后一个语句
//    printf("%d", a);
//    return 0;
//}
#include <stdio.h>
//多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。
//针对每行输入，输出用“*”组成的X形图案。
//输入：
//5
//输出：
// *   *
//  * * 
//   *  
//  * * 
// *   *
//int main()
//{
//    int a = 0;
//    while (scanf("%d", &a) != EOF) { // 注意 while 处理多个 case
//        // 64 位输出请用 printf("%lld") to 
//      
//        for (int i = 0; i < a; i++)
//        {
//            for (int j = 0; j < a; j++)
//            {
//                if (i == j || i + j == a - 1)
//                {
//                    printf("*");
//                }
//
//                else
//                    printf(" ");
//            }
//
//            printf("\n");
//        }
//
//
//    }
//    return 0;
////}
//KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“* ”组成的“空心”正方形图案。
//输入描述：
//多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“ * ”的数量。
////输出描述：
////针对每行输入，输出用“ * ”组成的“空心”正方形，每个“ * ”后面有一个空格。
//int main()
//{
//    int a = 0;
//    while (scanf("%d", &a) != EOF)
//    { // 注意 while 处理多个 case
//        // 64 位输出请用 printf("%lld") to 
//
//        for (int i = 0; i < a; i++)
//        {
//            for (int j = 0; j < a; j++)
//            {
//                if (i == 0 || j == 0 || i == a - 1 || j == a - 1)
//                {
//                    printf("* ");
//                }
//
//                else
//                    printf("  ");
//            }
//
//            printf("\n");
//        }
//
//
//    }
//        return 0;
// }
////}
//描述
//KiKi有一个矩阵，他想知道转置后的矩阵（将矩阵的行列互换得到的新矩阵称为转置矩阵），请编程帮他解答。
//
//输入描述：
//第一行包含两个整数n和m，表示一个矩阵包含n行m列，用空格分隔。(1≤n≤10, 1≤m≤10)
//
//从2到n + 1行，每行输入m个整数（范围 - 231~231 - 1），用空格分隔，共输入n * m个数，表示第一个矩阵中的元素。
//
//输出描述：
//输出m行n列，为矩阵转置后的结果。每个数后面有一个空格。
////
//
//int main()
//{
//    int m = 0;
//    int n = 0;
//    scanf("%d %d", &n, &m);
//    int arr[n][m];
//    for (int i = 0; i < n; i++)
//    {
//
//        for (int j = 0; j < m; j++)
//        {
//
//            scanf("%d", &arr[i][j]);
//        }
//    }
//
//    for (int i = 0; i < m; i++)
//    {
//
//        for (int j = 0; j < n; j++)
//        {
//
//            printf("%d ", arr[j][i]);
//        }
//        printf("\n");
//    }
////    return 0;
////}
//int main() {
//    int a[10] = { 0 };
//    for (int i = 0; i < 10; i++)
//
//    {
//        scanf("%d", &a[i]);
//
//    }
//    for (int i = 0; i < 10; i++)
//    {
//        int b = 0;
//        b = 9 - i;
//
//        printf("%d ", a[b]);
//    }
//
//
//
//    return 0;//逆序输出
//
//int main()
//{
//    int n, m;
//    int arr1[1000] = { 0 };
//    int arr2[1000] = { 0 };
//    scanf("%d %d\n", &n, &m);
//    for (int i = 0; i < n; i++)
//    {
//        scanf("%d", &arr1[i]);
//    }
//    for (int i = 0; i < m; i++)
//    {
//
//        scanf("%d", &arr2[i]);
//
//    }
//    int c = 0;
//    int d = 0;
//    while (c < n && d < m)
//    {
//        if (arr1[c] < arr2[d])
//        {
//            printf("%d ", arr1[c]);
//            c++;
//        }
//
//        else
//        {
//            printf("%d ", arr2[d]);
//            d++;
//        }
//    }
//    while (c < n)
//    {
//        printf("%d ", arr1[c]);
//        c++;
//    }
//    while (d < m)
//    {
//
//        printf("%d ", arr2[d]);
//        d++;
//    }
//
//    return 0;//有序合并
//}
////求十个数字的平均值
//int main()
//{
//    int a[10] = { 1,15,5,4,5,7,8,45,4,5 };
//    int sum = 0;
//    for (int i = 0; i < 10; i++)
//    {
//        sum += a[i];
//    }
//    int avr = 0;
//    avr = sum / 10;
//    printf("%d", avr);
//
//    return 0;
//}
//交换
//int main()
//{
//    int a[10] = { 1,2,2,2,2,2,2,2,2,2 };
//    int b[10] = { 2,1,1,5,4,6,88,888,99,9 };
//    for (int i = 0; i < 10; i++)
//    {
//        int tmp = 0;
//        tmp = a[i];
//        a[i] = b[i];
//        b[i] = tmp;
//
//
//    }
//   
//    for (int i = 0; i < 10; i++)
//    {
//        printf("%d ", a[i]);
//
//       
//
//    }
//    printf("\n");
//    for (int i = 0; i < 10; i++)
//    {
//        printf("%d ", b[i]);
//
//
//    }
////    return 0;
////}
//#include <stdio.h>
//int main()
//{
//    int a;
//    while (scanf("%d", &a) != EOF) {
//        //    { // 注意 while 处理多个 case
//        //        // 64 位输出请用 printf("%lld") to 
//        //
//        int arr[a][a];
//
//        for (int i = 0; i < a; i++)
//        {
//            printf("* ");
//        }
//        printf("\n");
//
//        for (int d = 1; d < a - 1; d++)
//        {
//            printf("* ");
//            for (int j = 1; j < a - 1; j++)
//            {
//                printf("  ");
//            }
//            printf("* ");
//            printf("\n");
//        }
//        for (int i = 0; i < a; i++)
////        {
////            printf("* ");
////        }
////        printf("\n");
////    }
////    return 0;
////}//空心正方形的第二种写法
// int Add(int x, int y)//形式参数
//{
//    /* int z = 0;
//     z = x + y;
//     return z;*/
//     return x + y;
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    //输入
//    scanf("%d %d", &a, &b);
//    ////计算
//    //int c = a + b;
//    //输出
//    int c = Add(a, b);//使用函数(调用)//真实传递给函数的参数叫实际参数，简称实参
//    printf("%d", c);
//    return 0;
//}
//
//void printf(void)
//{
//    printf("hello world");
//
//}
//int main()
//{
////    printf();
////
////    return 0;
//
//int Add(int x, int y)//形式参数
//{
//    /* int z = 0;
//     z = x + y;
//     return z;*/
//     return x + y;
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    //输入
//    scanf("%d %d", &a, &b);
//    ////计算
//    //int c = a + b;
//    //输出
//    int c = Add(a, b);//使用函数(调用)//真实传递给函数的参数叫实际参数，简称实参
//    printf("%d", c);
//    return 0;
//}

//
//int test()
//{
//    //int a = 0;
//    //scanf("%d", &a);
//    //if (a)//warning C4715: “test”: 不是所有的控件路径都you值
//    //    return 1;
//
//    int a = 0;
//    scanf("%d", &a);
//    if (a > 0)
//        return 0;
//    else 
//        return 1;
//}
//
//
//int main()
//{
//    int r=test();
//    printf("%d", r);
////    return 0;
////}
//
//void printf()
//{
//
//    printf("hello");
//}
//
//int main()
//{
////    printf();
////
//////    return 0;
//////}
////// 
////// 
////// 
////// 
////// 
//////函数的返回类型如果没写的话，编译器默认是int类型的值
////////如果函数要求返回值,但是函数中没有retur返回值,那具体返回什么就无法确定了
//int test()
//{
//    printf("hello world\n");
//    return 0;
//}
//int main()
//{
//    int r = test();
//    printf("%d",r);
//    return 0;
////}
//int test(int x,int y)
//
//{
//  
//    return x+y;
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d%d", &a, &b);
//   int r= test(a,b);
//   printf("%d", r);
//
//    return 0;
//}

//void set(int arr[10], int sz, int set)
//{
//    for (int i = 0; i <= 9; i++)
//    {
//        arr[i] = set;
//    }
//
// }
//
//void printf(int arr[],int sz)
//{
//    for (int i = 0; i < 10; i++)
//    {
//        printf("%d", arr[i]);
//    }
//
//}
//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    printf(arr, sz);
//    set(arr, sz, -1);
//    printf(arr,sz);
//    return 0;
//}
//
//void printf(int arr[3][5],int i,int j)
//
//{
//    for (int i = 0; i < 3; i++)
//    {
//        for (int j = 0; j < 5; j++)
//        {
//
//            printf("%d ", arr[i][j]);
//    
//        }
//        printf("\n");
//    }
//
//}
//
//int main()
//{
//    int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
//    printf(arr, 3, 5);
////
////    return 0;
//}
//假设计算某年某月有多少天
//
//int judgeyear(int y)//bool
//{
//    if ((y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)))
//    {
//        return 1;//return true
//    }
//    else
//        return 0;//return false
//}
//int get_days_of_month(int y, int m)
//{
//    int days[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
//    int day1 = days[m];
//    if (judgeyear(y) && m == 2)
//    {
//        day1++;
//
//    }
//    return day1;
//
//}
//
//int main()
//{
//    int year = 0;
//    int month = 0;
//    scanf("%d%d", &year, &month);
//   int day= get_days_of_month(year, month);
//   printf("%d", day);
////    return 0;
////}
//int main()
//{
//  /*  int len = strlen("abcdefg");
//    printf("%d", len);*/
//    printf("%d", strlen("abcdefg"));
//    return 0;
//}
//#include "add.h"
//
//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d%d", &a, &b);
//    int c = add(a, b);
//    printf("%d", c);
//
//    return 0;
//}
// extern int a;//extern声明外部变量
//int main()
//{
//    printf("%d", a);
//    return 0;
////}
//int bin_search(int arr[], int left, int right, int key)
//{       
//    scanf("%d", &key);
//                       
//            while (left <= right)
//            {
//                int mid = (left + right) / 2;//此处用mid=left+（left-right)/2更好,因为数组中数字有最大值,第一种方式有可能会出问题
//                if (arr[mid] < key)
//                {
//                    left = mid + 1;
//        
//                }
//                else if (arr[mid] > key)
//                {
//                    right = mid - 1;
//        
//                }
//                else
//                {
//                    return mid;
//                    break;
//        
//                }
//            }
//            if (left > right)
//            {
//                return -1;
//            }
//         
//
//}
//int main()
//{
//    int arr[] = { 1,2,5,6,7,9,10,15,18};
//    int len = sizeof(arr) / sizeof(arr[0]);
//    int d = 0;
//    int ret=bin_search(arr, 0, len - 1, d);
//    
//    if(ret==-1)
//    {
//        printf("没有找到");
//    }
//    else
//    {
//        printf("找到了,下标为%d", ret);
//    }
//    return 0;
//}
//    
//
//
//
//
//



// arr 是查找的数组
//left 数组的左下标
//right 数组的右下标
//key 要查找的数字



////利用函数打印99乘法表
//
//
//void func(int a)
//{
//    for (int i= 0;i <a+1; i++)
//    {
//
//        for (int j = 0; j < 1 + i; j++)
//        {
//            printf("%d*%d=%d ", i, j, i * j);
//        }
//
//        printf("\n");
//    }
//
// 
//}
//int main()
//{
// int b=0;
// scanf("%d",&b);
//    func(b);
//    return 0;
////}
//int judgeyear(int y)
//{
//    if ((y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)))
//        return 1;
//    else
//        return 0;
//}
//int main()
//{
//    int year = 0;
//    scanf("%d", &year);
//    int ret = judgeyear(year);
//    if (ret == 1)
//        printf("是");
//    else
//        printf("不是");
//    return 0;
////}
//int is_prime(int a)
//
//{
//    scanf("%d" , &a);
//    for (int i = 2; i <= a - 1; i++)
//    {
//        if (a % i == 0)
//            return 0;
//
//    }
//}
//int main()
//{
//    int a = 0;
//    int ret = is_prime(a);
//if (ret == 0)
//{
//    printf("no");
//
//}
//
//else
//{
//    printf("yes");
//}
//    return 0;
//}
//
//
//创建一个整形数组，完成对数组的操作
//
//实现函数init() 初始化数组为全0
//实现print()  打印数组的每个元素
//实现reverse()  函数完成数组元素的逆置。
//要求：自己设计以上函数的参数，返回值。
//

//void init(int arr[], int c, int d)
//{
//    for (int i = 0; i < c; i++)
//    {
//
//        arr[i] = d;
//    }
//  
//    
//}
//void print(int arr[], int c)
//{
//    for (int i = 0; i < c; i++)
//    {
//        printf("%d", arr[i]);
//
//    }
//
//}
//int main()
//{
//    int arr[] = { 0,1,2,3,4,5,6,7,8,9,10 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    init(arr, sz, 0);
//    print(arr,sz);
//
//
//        return 0;
//}
//void reverse(int arr[10],int b)
//{
//    
//   
//    for (b = 9; b>=0; b--)
//    {
//        printf("%d ", arr[b]);
//    }
//
//}
//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//    reverse(arr, 10);
//
//
//    return 0;
//}
//int main()
//{
//    int a = 1;
//    while (a = 1)
//    {
//        printf("杜海雷");
//    }
//}
//void test()
//{
//     static int a = 1;//加不加static结果不一样//静态
//     //编译器在编译代码时,就为静态变量分配了地址,
//    a++;
//    printf("%d ", a);
//}
//int main()
//{
//    int i = 0;
//    for (; i < 5; i++)
//    {
//
//        test();
//    }
//
//    return 0;
//}
//extern int g_val;//全局变量默认带有外部链接属性
//int main()//static修饰全局变量的时候,改变了全局变量的链接属性,使得变为了内部的链接属性,
////只能在自己的文件中使用
//{
//    printf("%d\n", g_val);
//
//    return 0;
//}
////e/*xtern int Add(int x, int y);
//int main()
//{
//
//    int a = 0;
//    int b = 0;
//    scanf("%d%d", &a, &b);
//    int c = Add(a, b);
//    printf("%d", c);
//    return 0;
//}*/
// 
// 
// 
//实现扫雷游戏 
//使用两个二维数组来实现
//如果大小是9*9,数组大小设计成11*11
//数组使用字符数组就行
//准备两个棋盘一个排查雷,一个显示雷
//先设计游戏菜单1开始0退出
//在设计棋盘
//打印两个棋盘
//一个都打印0,一个都打印*
//雷为1
//void lookboard(char board[rows][cols], int Row, int Col);
//
//int getminecount(char board[rows][cols], int x, int y)
//{
//    int count = 0;
//    for (int i = -1; i < 2; i++)
//    {
//        for (int j = -1; j < 2; j++)
//        {
//
//            count += board[x + i][y + j] - '0';
//        }
//
//    }
//    return count;
//}
//
//void findmine(char board1[rows][cols], char board2[rows][cols], int Row, int Col)
//{
//
//    int x = 0;
//    int y = 0;
//    int win = 0;
//
//    while (win<=row*col-easycount)
//    {
//        printf("请输入排查的坐标");
//        scanf("%d %d", &x, &y);
//        if (x >= 1 && x <= row && y <= col && y >= 1)
//        {
//
//            if (board1[x][y] == '1')
//            {
//                printf("很抱歉，你踩雷了，游戏结束\n");
//                lookboard(board2, row, col);
//                break;
//                
//            }
//            else
//            {
//                int count = getminecount(board1, row, col);
//                board2[x][y] = count + '0';
//                lookboard(board2, row, col);
//                win++;
//
//            }
//        }
//        else
//        {
//            printf("你输入的坐标有问题，请重新输入");
//        }
//
//
//
//    }
//
//
//
//}
//
//
//void setmine(char board[rows][cols], int Row, int Col)
//{
//    int count = easycount;
//    int x = 0;
//    int y = 0;
//
//    while (count)
//    {
//        x = rand() % row + 1;
//        y = rand() % col + 1;
//        if (board[x][y] != '1')
//        {
//            board[x][y] = '1';
//
//        }
//        count--;
//    }
//
//
//
//
//}
//
//
//
//void lookboard(char board[rows][cols], int Row, int Col)
//{
//    for (int i = 0; i < row + 1; i++)
//
//    {
//
//        printf("%d ", i);
//    }
//    printf("\n");
//    for (int i = 1; i <= row; i++)
//    {
//        printf("%d ", i);
//        for (int j = 1; j <= col; j++)
//        {
//            printf("%c ", board[i][j]);
//
//        }
//        printf("\n");
//    }
//
//}
//
//
//
//
//
//
//
//
//
//
//
//void initialboard(char board[rows][cols], int Row, int Col, char set)
//{
//    for (int i = 0; i < rows; i++)
//    {
//
//        for (int j = 0; j < cols; j++)
//        {
//            board[i][j] = set;
//        }
//
//    }
//}
//
//
//
//void game()
//{
//    //建立两个棋盘
//    char board1[rows][cols] = { 0 };
//    char board2[rows][cols] = { 0 };
//    //初始化两个棋盘
////一个放0,一个放*
//    initialboard(board1, rows, cols, '0');
//    initialboard(board2, rows, cols, '*');
//
//    //打印棋盘
//    lookboard(board1, row, col);
//    //lookboard(board2,row,col);
//
//    //布置雷
//    setmine(board1, row, col);
//
//    //lookboard(board1, row, col);
//    //排查雷
//    findmine(board1, board2, row, col);
//
//
//}
//
//
//
//
//void menu()
//{
//    int a = 0;
//    do
//    {
//
//        printf("          扫雷MENU\n");
//        printf("*******************************\n");
//        printf("***********1.start*************\n");
//        printf("***********0.exit**************\n");
//        printf("*******************************\n");
//        printf("*******************************\n");
//        printf("*******************************\n");
//        printf("请输入数字");
//
//        scanf("%d", &a);
//        switch (a)
//        {
//        case 1:
//            printf("开始游戏\n");
//            game();
//
//            break;
//        case 0:
//            printf("退出游戏\n");
//            break;
//        default:
//            printf("输入错误,请重新输入\n");
//            break;
//
//
//
//
//        }
//    } while (a);
//
//}
//
//
//
//
//
//void test()
//{
//    srand((unsigned int)time(NULL));
//    menu();
//
//
//}
//
//int main()
//{
//
//    test();
//
////    return 0;
////}
// int add(int a, int b)
//{
//    return a + b;
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    int c = add(a, b);
//    return 0;
//}

//F10创造断点
//F5跳过其他，直接到断点，是运行逻辑意义上的
//int main()
//{
//    
//        int i = 1;
//   
//        int j = 2;
//        int k = 3;
//    if (i++ == 1 && (++j == 3|| k++ == 3))
//        printf("%d %d %d\n", i, j, k);
//
//
//
//    return 0;
// 
//}
//求1到任意值的阶乘之和
////int main()
////{
////    int ret = 1;
////    int sum = 0;
////    for (int i = 1;  i<= 3; i++)
////    {
////        int ret = 1;
////        for (int j = 1; j <= i; j++)
////        {
////            ret = ret * j;
////
////        }
////        sum += ret;
////
////    }
////    printf("%d", sum);
////
////    return 0;
////}
//int main()
//{
//    int ret = 1;
//    int sum = 0;
//    for (int i = 1;  i<= 3; i++)
//    {
//      ret = ret * i;   
//        sum += ret;
//
//    }
//    printf("%d", sum);
//
//    return 0;
////}//这么写更简单
//int main()
//{
//    
//    
//    int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
//    int i = 0;
//    for (i = 0; i <= 12; i++)
//    {
//        arr[i] = 0;
//        printf("hehe\n");
//    }
//
//    return 0;
//}
//判断一个数是不是质数
//int judgea(int a)
//{
//    for (int i = 2; i <= a-1; i++)
//    {
//        if (a % i == 0)
//            return 0;
//    }
//    
//    return 1;
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret=judgea(a);
//    printf("%d",ret);
//    if (judgea(a) == 0)
//    {
//        printf("%d不是质数\n", a);
//
//    }
//    else
//    {
//        printf("%d是质数\n", a);
//    }
//
//    return 0;
//
// 
// }
//利用辗转相除法去判断两个数的最大公约数
//void judge(int a, int b)
//{
//    again:
//    int c = a % b;
//    if (c == 0)
//    {
//        printf("%d", b);
//    }
//    else
//    a = b;
//    b = c;
//   
//    {
//        goto again;
//    }
//
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d%d", &a, &b);
//    judge(a, b);
//    return 0;
//}
//void find()
//{
//
//
//}
//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10};
//    int a = 0;
//    scanf("%d", &a);
//    int left = 0;
//    int right = sizeof(arr) / sizeof(arr[0])-1;
//
//    find();
//    
//    return 0;
//}
//int main()
//{
//
//    char arr[] = { "abcdefg" };
//    printf("%d", strlen(arr));
//    return 0;
//
////}
//int main()
//{
//    char arr[] = { 'a','b','c','d' };
//    printf("%d", strlen(arr));//strlen计算遇到/0才会停止,
//    return 0;
//}
//int main()
//{
//    char arr[] = {"hello"};
//    printf("%d", sizeof(arr) );//sizeof会计算/0的长度
//    return 0;
//
//函数的递归}
//void print()
//{
//    printf("hello world\n");
//    print();
//}
//int main()
//{
//    print();
//
//    return 0;
//}
//求n的阶乘利用递归的思想
//n != n - 1!*n;
//int math(int n)
//{
//    if (n == 0)
//    {
//        return 1;
//    }
//    else if (n >0)
//    {
//        return n * math(n - 1);
//    }
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret=math(a);
//    printf("%d", ret);
//    return 0;
//
// }

//int math(int n)
//{
//    if (n == 0)
//    {
//        return 1;
//    }
//    else if (n >0)
//    {
//        Sleep(2000);
//        return n * math(n - 1);
//    }
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret=math(a);
//    printf("%d", ret);
//    return 0;
//
// }

//利用递归的思想去顺序打印每一位数字
// 如54321 打印5 4 3 2 1
//printf(12345)
//printf(1234)+5
//printf(123)+4
//一位一位打印出来
//void print(int n)
//{
//    if (n > 10)
//    {
//        print(n / 10);
//    }
//    Sleep(1000);
//    printf("%d ", n % 10);
//
//
//
//}
//
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//
//    print(a);
//    return 0;
//
// }
///利用递归的思想求斐波那契数列的第n项
//int count = 0;
//int fbnq(int a)
//{
//    if (a == 3)
//    {
//        count++;
//    }
//    if (a <= 2)
//    {
//        return 1;
//    }
//    else if (a > 2)
//    {
//        return fbnq(a-2) + fbnq(a - 1);
//
//    }
//    
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret = fbnq(a);
//    printf("%d\n", ret);
//    printf("count=%d", count);
////
////    return 0;
////}
//int main()
//{
//    char arr[2000] = { 0 };
//
//while(scanf("%s", arr)!=EOF)
//    
//        if (strcmp("王心韬",arr) == 0)
//        {
//            printf("傻逼");
//        }
//        else
//        {
//            printf("也是傻逼");
//        }
//        
//    return 0;
//}
////斐波那契数列更简便的算法
//
//int fbnq(int n)
//{
//    int a = 1;
//    int b = 1;
//    int c = 1;
//    while (n > 2)
//    {
//        c = a + b;
//        a = b;
//        b = c;
//        n--;
//
//    }
//    return c;
//
//}
//int main()
//{
//    int a = 0;
//    while (scanf("%d", &a) != EOF)
//    {
//        int ret = fbnq(a);
//        printf("%d\n", ret);
//    }
//
//    return 0;
//}
//int main()
//{
//     srand((unsigned int)time(NULL));
//     int a = rand();
//     int n = 0;
//     int c = 0;
//     scanf("%d", &c);
//     int count = 0;
//     int add = 0;
//     int sign = 1;
//
//   
//     for (a; a <= INT_MAX; a++)
//     {
//         while (c - count > 2)
//         {
//             if (a % 2 == 0)
//             {
//                 count += 2;
//                 n++;
//             }
//             else
//             {
//                 count++;
//                 n++;
//             }
//         }
//         if (c - count == 1)
//         {
//             count++;
//             n++;
//         }
//         else if (c - count == 2)
//         {
//             count += 2;
//             n++;
//         }
//         
//         sign = n;
//
//         if (count == c)
//         {
//             add++;
//         }
//     again:
//         a++;
//         count = 0;
//         while (c - count > 2)
//         {
//             if (a % 2 == 0)
//             {
//                 count += 2;
//                 n++;
//             }
//             else
//             {
//                 count++;
//                 n++;
//             }
//         }
//         if (c - count == 1)
//         {
//             count++;
//             n++;
//         }
//         else if (c - count == 2)
//         {
//             count += 2;
//             n++;
//         }
//
//         if (n != sign && c == count)
//         {
//             goto again;
//             add++;
//         }
//
//     }
//     printf("%d", add);
//    return 0;
//}、
//汉诺塔在c语言中的实现

//n是盘子的个数
//pos1是起始位置
//pos2是中转位置
//pos3是目标位置

//void move(char pos1,char pos2)
//{
//    printf("%c->%c", pos1, pos2);
//    
//}
//void hannuota(int n,char pos1,char pos2,char pos3)
//{
//    if (n == 1)
//    {
//        move(pos1,pos3);
//
//    }
//    else
//    {
//        hannuota(n - 1, pos1, pos3, pos2);
//        move(pos1, pos3);
//        hannuota(n - 1, pos2,pos1, pos3);
//    }
//
//}
//
//int main()
//{
//    int n = 0;
//    while (scanf("%d", &n) != EOF)
//    {
//        hannuota(n, 'A', 'B', 'C');
//    }
//    return 0;
////}
//int main()
//{
//    printf("%d\n", 153);
//    printf("%d\n", 0153);//数字前面加0表示是八进制数字
//    printf("%d\n", 0x153);//数字前面加0x表示是十六进制的数字
//
//
//    return 0;
//}
//int main()
//{
//    int a = 10;
//    //00000000000000000000000000001010 ——原码
//    //00000000000000000000000000001010——反码
//    //00000000000000000000000000001010——补码
//    //正数的原码,反码,补码都相同
//    int b=-10;
//    //10000000000000000000000000001010----原码
//    //11111111111111111111111111110101----反码
//    //11111111111111111111111111110110----补码
////负数的反码:符号位不变,其余都反过来,
//    //负数的补码,在反码的基础上加1,
//    return 0;
//}
//对于整形来说,数据存放内存中其实存放的是补码
//拿补码计算
// 
// 
//喝汽水，1瓶汽水1元，2个空瓶可以换一瓶汽水，给20元，可以喝多少汽水（编程实现）。
//// 
//int howmany(int Empty, int Drink)
//{
//    while (Empty > 1)
//    {
//        Drink = Drink + Empty / 2;
//        Empty = Empty / 2 + Empty % 2;
//       
//       
//
//    }
//    return Drink;
//}
//int main()
//{
//    int drink = 100;
//    int empty = drink;
//    int ret=howmany(empty,drink);
//    printf("%d", ret);
//    return 0;
//}
//作业内容
//用C语言在屏幕上输出以下图案：
	/**
  * * *
* * * * **/
///对称的图形，到以13个*为对称轴；



//void print()
//{
//    for (int n = 1; n <= 13; n += 2)
//    {
//        for (int c = 6; c >= (n + 1) / 2; c--)
//        {
//            printf("  ");
//        }
//        for (int j = 0; j < n; j++)
//        {
//
//            printf(" *");
//        }
//        printf("\n");
//    }
//    for (int n = 1; n <= 13; n += 2)
//    {
//        for (int c =1 ; c <=(n + 1)/2; c++)
//        {
//            printf("  ");
//        }
//        for (int j = 11; j >=n; j--)
//        {
//
//            printf(" *");
//        }
//        printf("\n");
//    }
//}
//int main()
//{
//    print();
//    return 0;
//}
//
//求出0～100000之间的所有“水仙花数”并输出。
//
//“水仙花数”是指一个n位数，其各位数字的n次方之和确好等于该数本身，如 : 153＝1 ^ 3＋5 ^ 3＋3 ^ 3，则153是一个“水仙花数”。
//void find()
//{
//   
//    for (int i = 0; i <= 100000000; i++)
//    {
//        int add = 0;
//        int turn = i;
//        int change = i;
//        while (turn)
//        {
//            turn /= 10;
//            add++;
//
//        }
//        int sum = 0;
//        while (change)
//        {
//          
//            
//            sum = sum + pow(change % 10, add);
//            change /=10;
//            
//        }
//        if (sum == i)
//        {
//            printf("%d\n", i);
//
//        }
//
//    }
//}
//int main()
//
//{
//    find();
//    return 0;
//}


//求/*Sn = a + aa + aaa + aaaa + aaaaa的前5项之和，其中a是一个数字，

//例如：2 + 22 + 222 + 2222 + 22222*/

//int Sn(int c)
//{
//    int sum = 0;
//    for (int j = 1; j <= 5; j++)
//    {
//        
//        for (int d = 1; d <= j; d++)
//        {
//            int f = c * pow(10, d-1);
//            sum += f;
//        }
//
//    }
//    return sum;
//
// }
//
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret=Sn(a);
//    printf("%d", ret);
//    return 0;
//}
////或者
//int Sn(int c)
//{
//    int n = 5;
//    int tmp = 0;
//    int sum = 0;
//    for (int i= 1;i <= n;i++)
//    {
//        tmp = tmp * 10 + c;
//        sum += tmp;
//    }
//
//    return sum;
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//int ret= Sn(a);
//printf("%d", ret);
//    return 0;
//}
//int Fun(int n)
//{
//    if (n == 5)
//        return 2;
//    else
//        return 2 * Fun(n + 1);
//}
//int main()
//{
//    
//    printf("%d",Fun(2));
//    return 0;
//}
//int fbnq(int b)
//
//{
//    if (b == 1 || b == 2)
//    {
//        return 1;
//
//}
//    else
//    {
//        return fbnq(b - 1) + fbnq(b - 2);
//    }
//}
//
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret=fbnq(a);
//    printf("%d", ret);
//    return 0;
//}
//
//int fbnq(int n)
//{
//    int a = 1;
//    int b = 1;
//    int c = 1;
//    while (n > 2)
//    {
//        c = a + b;
//        a = b;
//        b = c;
//        n--;
//    }
//    return c;
//
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    printf("%d",fbnq(a));
//    return 0;
//}
//编写一个函数实现n的k次方，使用递归实现。
//n^ k = n ^ k - 1 * k;
//int math(int d,int f)
//{
//    if (f == 0)
//    {
//        return 1;
// }
//    else
//    {
//        return d * math(d, f - 1);
//
//    }
//}
//int main()
//{
//    int n = 0;
//    int k = 0;
//    scanf("%d%d", &n, &k);
//    int ret=math(n,k);
//    printf("%d", ret);
//    return 0;
////}
//写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和
//
//例如，调用DigitSum(1729)，则应该返回1 + 7 + 2 + 9，它的和是19
//
//输入：1729，输出：19
//int DigitSum(int d)
//{
//    int sum = 0;
//    while (d)
//    {
//        sum += d % 10;
//        d = d / 10;
//
//
//    }
//    return sum;
//}
//
//
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret=DigitSum(a);
//    printf("%d", ret);
//    return 0;
//}
/*nt digitsum(int d)
{


	if (d<10)
	{
		return d;
	}
	else
	{

	  return  digitsum(d / 10)+d%10;
	}

}
int main()

{
	int sum = 0;
	int a = 0;
	scanf("%d", &a);
	int ret=digitsum(a);
	printf("%d", ret);
	return 0;
}*/

//
//作业标题(686)
//求阶乘
//
//作业内容
//递归和非递归分别实现求n的阶乘（不考虑溢出的问题）
//递归的方式
//int math(int d)
//{
//    if (d == 1)
//    {
//        return 1;
//    }
//    else
//    {
//
//        return math(d - 1) * d;
//    }
//}
//
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int ret = math(a);
//    printf("%d", ret);
//    return 0;
//}
//不使用递归的方式
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int sum = 1;
//    for (int i = 1; i <= a; i++)
//    {
//       
//        sum *= i;
//
//    }
//    printf("%d", sum);
//    return 0;
//}
//打印每个数的第一位

//
//void Print(int d)
//{
//   
//    if (d>10)
//    {
//        Print(d/10);
//        
//    }
//    printf("%d ", d % 10);
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    Print(a);
//    return 0;
//}

//
//int main()
//{
//    printf("hello world\n");//
//    main();
//    return 0;
//}


// {
//    int a = 0;
//    for (a=0; a < 10; a++)
//    {
//
//        printf("%d",a);
//    }
//    return 0;
// }
//int main()
//{
//    int a = 0;
//    for (a = 0; a < 10; a++)
//    {
//
//        printf("%d", a);
//    }
//
//    return 0;
//        
//
//int main()
//{
//    srand((unsigned int) time(NULL));
//    int a = rand();
//    printf("%d", a);
//
//    return 0;
////}
//int main()
//{
//    for (int i = 0; i <= 10; i++)
//    {
//
//        printf("%d", i);
//
//    }
//    return 0;
//}
//}
//int main()
//{
//    int a = 10;
//    //00000000000000000000000000001010 ——原码
//    //00000000000000000000000000001010——反码
//    //00000000000000000000000000001010——补码
//    //正数的原码,反码,补码都相同
//    int b=-10;
//    //10000000000000000000000000001010----原码
//    //11111111111111111111111111110101----反码
//    //11111111111111111111111111110110----补码
////负数的反码:符号位不变,其余都反过来,
//    //负数的补码,在反码的基础上加1,
//    return 0;
//}
//对于整形来说,数据存放内存中其实存放的是补码
////拿补//0正1负
//移位操作符<< >>
////只能对整数使用
//int main()
//{
//    int a = 10;
//    int b = a << 1;
//    //000000000000000000000000001010;
//    //000000000000000000000000010100;
//    printf("%d", b);
//    return 0;
////}
//int main()
//{
//    int a = -1;
//    //1000000000000000000000000000001
//    //1111111111111111111111111111110;
//    //1111111111111111111111111111111;
//    int b = a << 1;
//    printf("b=%d", b);
//    return 0;
////}
//int main()
//{
//    int a = -10;
//    //10000000000000000000000000000001010
//    //11111111111111111111111111111110101
//    //10000000000000000000000000000000110
//    int b = a >> 1;
//    //右移采用算数右移还是逻辑右移取决于编译器
//    // 一般的编译器采用的都是算数右移
//    // 00000000000000000000000000000000110
//    printf("b=%d", b);
//    return 0;
//}
//位操作符
//& | ^ ~也只能操作整数
////&按位与 |按位或(二进制）
//int main()
//{
//    int a = 6;
//    //00000000000000000000000000000000110(32位)
//    int b = -7;
////100000000000000000000000000000000111;
////111111111111111111111111111111111000'
////111111111111111111111111111111111001;
//    ///*int c = a & b;*/0
//    //int c = a^b;//-1
////    |   反过来
//    //&有0则为0，都为1则为1；
////000000000000000000000000000000000000;
//    //111111111111111111111111111111111001
//   // ^按位异或 相同为0 相异为1
//    //~按二进制位取反
//    int c = 0;
//    printf("c=%d", ~c);
//    return 0;
//}
////不让创建临时变量,实现两个整数的交换
//int main()
//{
//    //int tmp=a;
//    // a=b;
//    // b=tmp;
//    //
//    //
//    int a = 3; 
//    int b = 5;
//  /*  a=a + b;
//    b=a - b;
//    a = a - b*/;//交换的第二种方式
//
//    //第三种
//    a = a ^ b;
//    b = a ^ b;//b=a^b^b=>b=a;
//    a = a ^ b;//101 000//101
//    //0^任何值=该值；
//    printf("%d %d", a, b);
//    return 0;
//}
// 

// //求一个整数存储在内存中二进制1的个数
//
//int count(/*unsigned */int n)
//{/*
//    int count = 0;
//    while (c)
//    {
//        if ((c % 2) == 1)
//            count++;
//        c = c / 2;
//    }*/
//    int count = 0;
//    /*for (int i = 0; i <= 31; i++)
//    {
//        if (c & 1 == 1)
//        {
//            count++;
//            c = c >> i;
//
//        }
//        else
//        {
//
//            c = c >> i;
//        }
//
//    }*/
//    //这种方式不用考虑符号
//    //一个数&1得到最后一位
//    while (n)
//    {
//
//        n = n & n - 1;
//        count++;//把n的二进制序列最右边的1去掉
//    }
//
//    return count;
//}
//
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    printf("%d", count(a));
//    return 0;
//}
//写一个代码，判断是否是二的次方数

//int judge(int c)
//{
//   
//    
//        c = c % 2 ;
//    
//        if (c == 0)
//        {
//            return 1;
//
//        }  
//    return 0;
//}
//
//
//int main()
//{
//    int  a = 0;
//    scanf("%d", &a);
//        //printf("%d", judge(a));
//    int ret = judge(a);
//    if (ret==1)
//    {
//        printf("shi");
//
//    }
//    else if(ret==0)
//    {
//
//        printf("bushi");
//    }
//    return 0;



//使用本章所学知识来敲写
//void judge(int c)
//{
//    int count = 0;
//    while (c)
//    {
//        c = c & c - 1;
//        count++;
//    }
//    if (count == 1 && c != 1)
//    {
//        printf("shi");
//
//    }
//    else
//
//    {
//        printf("buhsi");
//    }
//
//}
//
//int main()
//{
//    int a = 0;
//    scanf("%d",&a);
//    judge(a);
//    return 0;
//}


//int add(int c, int d)
//{
//    return c + d;
//
//}
//int main()
//{
//    int c = 0;
//    int a = 0;
//    int b = 1;
//    printf("%d\n",add(a, b));
//
//    c = a * b;
//    printf("%d", c);
//    return 0;
//}
//编写代码将13的第五位改为1，然后再该为零
////n
//int main()
//{
//
//    int a = 13;
//    int n = 5;
//    a = a ^ (1 << (n - 1));//|
//
//    printf("%d\n", a);
//
//    //a = a ^ (1 << (n - 1));
//    //a = a & ~(a << (n - 1));
//
//    printf("%d\n", a);
//
//    return 0;
//}
//int main()
//{
//    int a = 1;
//    int b = 2;
//    int c = (a > b, a = b + 10, a,b = a + 1);
//    //逗号表达式，一定要从左到右依次计算
//
//    printf("%d", c);
//}
//int main()
//{
//    int a = 0;
//    int b = 0;
//    int c = 0;
//    int d = 0;
//    if (a == 1, b == 0, c * 2 == 0, d == 0)
//    {
//        printf("hehe");//伪代码
//    }
//}
//int main()
//{
//    main();
//    printf("%d", 100);
//
//}
//结构成员访问操作符
//int main()
//{
//    char arr[] = { 'a','b','c'};
//    int a = strlen(arr);
//    printf("%d", a);
//    return 0;
//}


//关键字 struct
// struct tag----自定义
// {
// 
// menber-list;--成员列表
// 
// }variable-list;--变量列表
// 
// 
// 
// 
////
//struct student
//{
//    char name[20];
//    int age;
//    float score;
//
//}s4,s5,s6;
//int main()
//{
//    int a;
//    struct student s1 = {"wnagwu",20,89.0};
//    struct student s2;
//    return 0;
//}

//struct point
//{
//    int GPA;
//    int y;
//};
//
//
//struct student
//{
//    char name[20];
//    int age;
//    double score;
//    struct point s1;
//};
//
//int main()
//{
//    struct student s2= { "wnagwei",20,4.0,{3,5} };
//    struct point c = { 3,5 };
//    printf("%s",s2.name);
//    printf("%d", s2.s1.GPA);
//    printf("%lf", s2.score);
//    //结构体变量。名字
//    
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    a++;
//    ++a;
//    return 0;
//
//
// 
//多个操作符，优先级高的先执行
//优先级相同时,从左到右执行;


//int main()
//{
//    char b = 100;
//    char a = 20;
//    char c = a + b;//char  -128~127;超过这个范围所以得不出150
//    printf("%d", c);
//    
//}
//
//int fun()
//{
//    static int count = 1;
//    return ++count;
//}
//
//int main()
//{
//   /* int c = 0;
//   printf("%d" ,c + --c);*/
//                                                                                                                                                                                                                     
//                                            
//    /*nt a = 0;
//    
//    a = fun() - fun() * fun();
//    printf("%d", a);*/
//                           
//    return 0;           
//}    
// 


////  
//int judge(int d)
//{
//    
//   
//        for (int j = 2; j <= d - 1; j++)
//        {
//
//
//            if (d % j == 0)
//            {
//                return 0;
//
//            }
//        }
//
//
//
//    
//    return 1;
//}
//int main()
//{
//    int i = 0;
//    for (i = 200; i <= 300; i++)
//    {
//
//
//        if (judge(i) == 1)
//        {
//            printf("%d\n", i);
//
//
//        }
//
//    }
//   在一个整型数组中，只有一个数字出现一次，其他数组都是成对出现的，请找出那个只出现一次的数字。

//例如：
//
//数组中有：1 2 3 4 5 1 2 3 4，只有5出现一次，其他数字都出现2次，找出5
////
//int judge(int i)
//{
//
//
//    int arr[] = { 1 ,2, 3, 4, 5, 1, 2, 3, 4 };
//
//
//        for (int j = 0; j <= 8; j++)
//        {
//
//            if (arr[i] == arr[j] && i!= j)
//            {
//                return 0;
//
//            }
//
//
//        }
//        return 1;
//
//
//    
//}
//int main()
//{
//  
//    int arr[] = { 1 ,2, 3, 4, 5, 1, 2, 3, 4 };
//
//    for (int i = 0; i <= 8; i++)
//    {
//        judge(i);
//        if (judge(i) == 1)
//        {
//            printf("%d", arr[i]);
//
//        }
//    }
//    
//}
//或者use 0^n=n   n^n=0
//int main()
//    {
//    int sum = 0;
//    int arr[] = { 1 ,2, 3, 4, 5, 1, 2, 3, 4 };
//    for (int i = 0; i <= 8; i++)
//    {
//        sum ^= arr[i];
//
//    }
//    printf("%d", sum);
//
//
//    return 0;
//
//    }
//获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列
//void print(int d)
//{
//    for (int i = 0; i <= 30; i += 2)
//    {
//
//        printf("%d", (d >> i) & 1);
//    }
//    printf("\n");
//    for (int i = 1; i <= 32; i += 2)
//    {
//
//        printf("%d", (d >> i) & 1);
//    }
//
// }
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    print(a);
//
//
////}
//
//编程实现：两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同？
//
//输入例子 :
//
//1999 2299
//
////输出例子 : 7
//int math(int c,int e)
//{
//    int d = c ^ e;
//    int count = 0;
//    /*while(d)
//    {
//        d = d & d - 1;
//        count++;
//
//    }*/
//    //while (d)
//    //{
//    //    if (d & 1 == 1)
//    //    {
//
//    //        count++;
//    //       d = d / 2;
//    //    }
//    //    else
//    //    {
//    //        d /= 2;
//
//    //    }
//
//    //}
//    for (int f = 1; f <= 31; f++)
//    {
//        if ((d  & 1) == 1)
//        {
//            d = d >> f;
//         count++;
//
//        }
//        else
//        {
//            d=d >> f;
//
//        }
//    }
//    //        if (c & 1 == 1)
//    //        {
//    //            count++;
//    //            c = c >> i;
//    //
//    //        }
//    //        else
//    //        {
//    //
//    //            c = c >> i;
//    //        }
//    return count;
//
//}
//int main()
//{
//    int m = 0;
//    int n = 0;
//    scanf("%d %d", &m, &n);
//    int ret=math(m,n);
//    printf("%d", ret);
//
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    int count = 0;
//    int sum = 0;
//    for (int j = 0; j <= 31; j++)
//    {
//        if ((a >> j) & 1 == 0)
//        {
//            count++;
//
//
//        }
//
//    }
//    printf("%d\n", count);
// /*   for (int j = 1; j <= 31; j++)
//    {
//
//        if ((a & 1) == 0)
//        {
//            sum++;
//            a = a >> j;
//        }
//        else
//        {
//            a = a >> j;
//
//        }
//        
//    }
//    printf("%d", sum);*///这种方法错误的原因是本质上改变了a的大小，a的最后一位会随着新数而变化
//    return 0;
//}
//#include <stdio.h>
//int main()
//{
//    int i = 1;
//    int ret = (++i) + (++i) + (++i);
//    printf("ret = %d\n", ret);
//    return 0;
//}
//#include <stdio.h>
//int i;
//int main()
//{
//    i--;
//    if (i > sizeof(i))
//
//
//    {
//        printf(">\n");
//    }
//    else
//    {
//        printf("<\n");
//    }
//    return 0;
//}
//‌全局变量如果不初始化，则默认为0。
//int main()
//{
//    /*unsigned char a = -1;
//
//    
//    printf("%d", a);*/
//
//    char a = -1;
//    printf("%u", a);
//    return 0;
//}
//i
// //
//int main()
//{
//    int a = 20;
//    printf("%p\n", &a);
//
//    int * pa = &a;//pa是一个变量，这个变量是用来存放地址（指针）的
// //pa叫做指针变量
//    //int *是pa的类型
//    //*表示pa是指针变量
//    //int 表示pa指向的变量a的类型是int
//    return 0;
//}

//int main()
//{
//    int a = 20;
//    int * pa = &a;
//    *pa = 200;//*解引用操作符
//    printf("%d\n", sizeof(pa));
//    return 0;
//}
//
//int main()
//{
//    printf("%zd ", sizeof(char*));
//
//    printf("%zd ", sizeof(short*));
//
//    printf("%zd ", sizeof(double *));
//
//    printf("%zd ", sizeof(float*));
//
//    printf("%zd " , sizeof(int*));
//
//    return 0;
//}
//int main()
//{
//    int a = 0x11223344 ;
//    int* pa = &a;
//    *pa = 0;
//    return 0;
//
// }
//int main()
//{
//    int a = 0x11223344;
//    char* pa = (char *) & a;
//    *pa = 0;
//
//    return 0;
//
// }
// 

//char*类型的解引用只能访问一个字节，而int*可以访问四个字节
//int main()
//{
//    int a = 20;
//    int* pa = &a;
//    char* pc = (char*)&a;
//    printf("&a=%p\n", &a);
//    printf("pa=%p\n", pa);
//    printf("pc=%p\n", pc);
//    
//    printf("&a+1=%p\n", &a+1);
//    printf("pa+1=%p\n", pa+1);
//    printf("pc+1=%p\n", pc+1);
//
//    return 0;
//}
//int main()
//{
//   const int num = 100;
//   //const修饰变量的时候 叫变量
//   //这个被修饰的变量本质上还是变量,只是不能被修改
//    
//    printf("%d", num);
//
//    return 0;
//}
//int main()
//{
//    const int n = 20;
//    int* p = (const*) & n;
//    *p = 200;
//    printf("%d", n);
//
//
//    return 0;
//}
//int main()
//{
//    int n = 10;
//    int m = 200;
//    int * p  = &n;
//    //int const * p= &n ;
//    //int  * const p= &n ;
//    //int const * const p= &n ;
//    *p = 20;
//    p = &m;
//
//
//    return 0;
//}
//int main()
//{
//   /* int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d ", arr[i]);
//
//    }*/
//
//    int arr[10] = { 1,2,4,4,5,6,7,8,9,10 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    int * parr = &arr[0];
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d", *(parr + i));
//        //printf("%d", *parr);
//        /*parr++;*/
//
//    }
//    return 0;
//}
//
//int main()
//{
//    int arr[10] = { 1,2,3,5,6,4,7,8,9,10 };
//    printf("%d\n",&arr[9]-&arr[0]);
//    return 0;
//}
//指针减去指针的绝对值是指针与指针之间元素的个数
//前提条件是两个指针指向的是一个空间

////写一个函数 求字符串的长度
//size_t my_strlen(char * p)
//{
//   /* char* start = p;
//    char* end = p;
//    while (*end != '\0')
//    {
//        end++;
//    }
//    return end - start;
//*/
//
//
//
//    /*int count = 0;
//    while (*p != '\0')
//    {
//        p++;
//        count++;
//}
//    return count;*/
//
//}
//
//int main()
//{
//    char arr[] = "abcdefg";
// /*   int len = strlen(arr);
//    printf("%d", len);*/
//    size_t len = my_strlen(arr);//数组名其实是数组首元素的地址arr==&arr【0】
//    printf("%d", len);
//    return 0;
//}
//int main()
//{
//    int arr[10] = { 0,2,3,5,6,7,8,9,10,11 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    int* p = &arr[0];
//    while (p<&arr[sz])
//    {
//        printf("%d", *p);
//        p++;
//
//    }
//
//
//    return 0;
//}
//野指针 //指针指向的位置是不可知的,随机的,不正确的,没有明确限制的
//int* test()
//{
//    int n = 10;
//    return &n;
//
//}
//int main()
//{
//
//    int* p = test();
//    printf("%d", *p);
//    return 0;
//

//}

//int main()
//{
//    int* p = NULL;
//    if (p != NULL)
//    {
//        *p = 200;
//
//    }
//
//    return 0;
//}
//assert 断言


//int main()
//{
//    int a = 0;
//    for (a; a <= 10; a++)
//    {
//        printf("%d", a);
//        Sleep(1000);
//
//    }


//int main()
//{
//    int* p = NULL;
//    assert(p != NULL);
//    
//
//    return 0;
//}
//release版本 直接会优化掉assert
///debug版本才可以使用

//指针
//size_t my_strlen(const char* p)
//{
//    size_t count = 0;
//    assert(p != NULL);
//    while (*p)
//    {
//        p++;
//        count++;
//    }
//    return count;
//
//}
//int main()
//{
//    char arr[] = { "abcdefg" };
//    size_t len=my_strlen(arr);
//    printf("%zd", len);
//    return 0;
//}

//传值调用 传指调用


//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d %d", &a, &b);
//
//    swap1(a, b);
//    printf("%d %d", a, b);
//
//
//    return 0;
//}void swap1(int x, int y)
//{
//    int z = x;
//    x = y;
//    y = z;
//}
////此处 x y的值发生了交换 但是 a和b的值没有变 

//void swap1(int *c,int *d)
//{
//    int each = 0;
//    each = *c;
//    *c = *d;
//    *d = each;
//
//
//
//}
//
//
//int main()
//{
//    int a = 0;
//    int b = 0;
//    scanf("%d %d", &a, &b);
//
//    swap1(&a, &b);
//    printf("%d %d", a, b);
//
//
//    return 0;
//}

//9.6
//指针和数组相关的知识


//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//    int *pa=&arr[0];
//    //%p打印地址
//
//    //其实 数组名是数组首元素的地址
////有两个例外 sizeof 这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
//// &数组名
//    //这里的与上个类似 取出的是整个数组的地址
//
//    printf("%p\n", &arr[0]);
//    printf("%p\n", arr);
//    printf("     ");
//    printf("%zd\n", sizeof(arr));
//    printf("%p\n", &arr);
//    //&arr[0]=arr
//
//    printf("%p\n", &arr[0]+1);//+4
//    printf("%p\n", arr+1);//+4
//    printf("     ");
//    printf("%zd\n", sizeof(arr));
//    printf("%p", &arr+1);//+40
//    return 0;
//}
//int main()
//{
//    
//    int arr[10] = { 0 };
//
//    int sz = sizeof(arr) / sizeof(arr[0]);
//
//    int i = 0;
//    for (i = 0; i < sz; i++)
//    {
//        scanf("%d", &arr[i]);
//
//    }
//    for (i = 0; i < sz; i++)
//    {
//
//        printf("%d", arr[i]);
//    }
//
//
//    return 0;
//}
//int main()
//{
//    int arr[10] = { 0 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    int* p = arr;
//    for (int i = 0; i < sz; i++)
//    {
//        scanf("%d", p + i);
//
//    }
//    for (int i = 0; i < sz; i++)
//    {
//
//        printf("%d", *(p + i));
//    }
////    return 0;
//int main()
//{
//    int arr[10] = { 0 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    int* p = arr;
//    for (int i = 0; i < sz; i++)
//    {
//        scanf("%d",arr + i);
//
//    }
//    for (int i = 0; i < sz; i++)
//    {
//
//        printf("%d", *(arr + i));
//    }
//    return 0;
//
//}

//*(arr+i)========arr[i]========*(i+arr)==========i[arr]
//int main()
//{
//    int arr[10] = { 0 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    int* p = arr;
//    for (int i = 0; i < sz; i++)
//    {
//        scanf("%d", &i[arr]);
//
//    }
//    for (int i = 0; i < sz; i++)
//    {
//
//        printf("%d",i[arr]);
//    }
//    return 0;
//}
//数组就是数组 是一块连续的空间 
//指针变量是一个变量 不是一回事 
//为什么可以使用指针来访问数组呢
//1.数组在内存中连续存放
//2.指针的运算很方便的可以便利数组,取出数组的内容
//void test(int arr[])
//{
//    int sz2 = sizeof(arr) / sizeof(arr[0]);
//    printf("%d", sz2);
//    //
//}
//void test(int arr[],int sz)
//{
// 
//}
//int main()
//{
//    int arr[10] = { 0 };
//    int sz1 = sizeof(arr) / sizeof(arr[0]);
//    printf("%d\n", sz1);
//    test(arr,sz1);
//    //arr是数组名 数组名表示数组首元素的地址
//    //数组传参 本质上是传递首元素的地址
//    //可以写成数组 也可以写成指针 但本质上是指针 
//
//    return 0;
//}

//冒泡排序
//void input(int arr[], int sz)
//{
//    int i = 0;
//    for (i; i < sz; i++)
//    {
//        scanf("%d", &arr[i]);
//
//    }
//
//}
//void bubble_sort(int arr[], int sz)
//{
//
//    int i = 0;
//    for (i; i < sz - 1; i++)
//    {
//
//        int flag = 0;
//        int j = 0;
//        for (j; j < sz - 1 - i; j++)
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                flag = 1;
//                int tmp = arr[j];
//                arr[j] = arr[j + 1];
//                arr[j + 1] = tmp;
//            }
//
//
//        }
//            
//        if (flag == 0)
//        {
//            break;//可以优化一下 
//        }
//
//    }
//
//
//}
//void print(int arr[], int sz)
//{
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d", arr[i]);
//
//    }
//
//
//}
//int main()
//{
//    int arr[10] = { 0 };
//    //输入一些值
//    //乱序 
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    input(arr, sz);
//    bubble_sort(arr,sz);
//
//    print(arr,sz);
//    //排序 写一个函数 完成函数的排序 ,升序的方式
//
//
//
//}


////二级指针 
//int main()
//{
//    int a = 10;
//    int* pa = &a;
//    int** pa1 = &pa;//此处的pa1即为二级指针
//    //二级指针变量是用来存放一级指针变量的地址
//    printf("%d", **pa1);
//
//    return 0;
//
//    
//}
//指针数组 
//int main()
//{
//    
//    int a = 10;
//    int b = 20;
//    int c = 30;
//    int* arr[] = {&a,&b,&c };
//    for (int i = 0; i < 3; i++)
//    {
//        printf("%d ", *arr[i]);
//    }
//
//
//
//
//    return 0;
//
// }
//
//int main()
//{
//    int arr1[5] = { 1,2,3,4,5 };
//    int arr2[5] = { 2,3,4,5,6 };
//    int arr3[5] = { 3,4,5,6,7 };
//    int* arr[] = { arr1,arr3,arr2 };
//    for (int i = 0; i <= 2; i++)
//    {
//        for (int j = 0; j <= 4; j++)
//        {
//            printf("%d ",*(*(arr+i)+j));
//            //arr[i]=*(arr+i)
//        }
//        printf("\n");
//    }
//
//
//    return 0;
//
// 
// 
// }
//int main()
//{
//
//    //char ch = 'w';
//    //char* pch = &ch;
//    //char * p = "abcdef";
//   /* char arr[] = "abcdefg";
//    char* p = arr;*/
//
//  const char* p = "abcdefg";
//  //常量字符串不能被修改 
//  //这里的赋值 是将字符串中首字符的地址赋值给p
//  char arr[] = { "abcdefg" };
//  printf("%s", &arr[0]);//arr
//  
//  
//
//  printf("%c ", *p);// a
//
//  printf("%s", p);//使用%s打印字符串的额时候 ，只需要提供首字符的地址
//}
//int main()
//{
//    char str1[] = "hello bit";
//    char str2[] = "hello bit";
//
//    const char* str3 = "hello bit";
//    const char* str4 = "hello bit";
//    
//    if (str1 == str2)//数组名是首元素的地址 
//    {
//        printf("same");
//
//    }
//    else
//        printf("not same");
//    if (str3 == str4)
//    {
//        printf("same");
//
//    }
//    else
//        printf("not same");//内容相同的常量字符串只需要保存一份就够了
//
//    return 0;
//}
//指针数组 是数组 存放的是指针 
//数组指针 指向数组的指针 数组指针存放的是数组的地址
//int main()
//{
//    int arr[10] = { 0 };
//    int(* p)[10] = &arr;
//    //int (*)[10]
//    //arr int*  arr+1跳过4个 下同
//    //&arr[0] int*
//    //&arr int(*)[10] &arr+1 跳过四十个字节 
//
//    //int *p[]
//
//
//
//    return 0;
//}
//int main()
//{
//    //char * arr[5];
//    //char *(*pc)[5] = &arr;
//    //int a = 5;
//    //int* paa = &a;
//    //char arr5[6];
//    //char(*p)[6] = &arr5;
//    //int *pa = &a;
//    //char a1 = 'a';
//    // char  *pa4 = &a1;
//    // //指针数组  char  * arr[6] int *arr[5]
//    // //数组指针  char (*arr)[6]
//     int arr[10] = { 0,12,3,4,5,6,7,8,9,10 };

	//// 
	// int(*pa)[10] = &arr;

	// int i = 0;
	// for (i; i < 10; i++)
	// {

	//     printf("%d ", (*pa)[i]);

	// }

//     int* p = arr;
//     for (int i = 0; i < 10; i++)
//     {
//         printf("%d ", i[p]);
//         //arr[i]==)*(*(arr+i)+j)==*(i+arr)==i[arr]
//     }//hao
//
//    return 0;//小题大作 
//}//int a=0;
//int*pa=&a;
//*pa
//二维数组传参的本质

//int arr[5]
//void Print(int(*pa)[5], int r, int c)
//{
//    int i = 0;
//    for (i; i < r; i++)
//    {
//        for (int j = 0; j < c; j++)
//        {
//                         //arr
//            printf("%d ", *((*(pa + i))+j));
//
//        }
//
//        printf("\n");
//    }
//
//}
////int arr[10];
////int*pa=&arr[0];
////        int(*pa)[10]=&arr;
//
//
//int main()
//{
//    int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
//    Print(arr, 3, 5);
//
//    return 0;//二维数组的数组名也是首元素的地址
//}
//不管是一维数组传参还是二维
////形参可以写成数组 也可以写成指针 
//
////
//int add(int x, int y)
//{
//    return x + y;
//
//}
//void print()
//{
//    printf("a");
//}
//int main()
//{
//    int a = 10;
//    int* pa = &a;
//
//    int arr[5] = { 0 };
//    int(*pa1)[5] = &arr;
//    printf("%p ", add);
//    printf("%p ", &add);
//    //&函数名 函数名都是函数的地址 没有区别
// int a=5;
// int (*pa)=&a
//    int (*pf)(int x ,int y) = &add;//函数指针变量
//    printf("%d ", (*pf)(4, 5));
//    printf("%d ", (*********pf)(4, 5));
//    printf("%d ", pf(4, 5));
//    //                 add(4,5) 
//    //void(*pa1)(void) = &print;
//    //int (*)(int ,int )//函数指针变量
//
//    return 0;
//}


//int main()
//{
//   //函数指针类型
//    (void (*)())0;
//    (     *(void( * )())    0   )();
//    //意思 是一次函数调用 调用0地址处放的那个函数 
//    //0地址处放的这个函数是无参,返回类型是void
//
//    /*printf("%d",int(3.14));*/
//    
//    int(3.14);//整形转换
//
//    //      函数名   函数参数 int 函数指针类型
//    void (*signal(int, void(*)(int)))(int);
//    void(*)(int) signal(int, void(*)(int));
//    //函数 正常来说应该是下面那种写法 但是语法只允许上面那种 
//
//    void(*)int 函数返回类型
//
//    return 0;

//上面的代码是一次函数声明 signal 
//有两个参数 int 函数指针
//返回类型也是一个函数指针 返回类型是void



//}
//函数调用 add(3,5)
//函数声明 int add(int int)

typedef unsigned int uint;

//typedef
//int main()
//{
//    unsigned int num1;
//    uint num2;
//
//
//    return 0;
//}

typedef int* pint_t;
//int main()
//{
//    int a = 0;
//    int* p = &a;
//    pint_t pa;
//    return 0;
//}

typedef int(*parr_t)[6];//函数指针类型需要放到*旁边
//int add(int x, int y)
//{
//    return x + y;
//}
//
typedef int(*parr1_t)(int, int);
//
//typedef void(*p2)(int);
//int main()
//{
//    int arr[6] = { 0 };
//    int (*p)[6] = &arr;
//    parr_t pa = &arr;1
//
//    add(3,5);
//    int(*pf)(int, int) = add;
//    
//    parr1_t pf2 = add;
//
//    //进行简化 
//    void (*signal(int, void(*)(int)))(int);
//    p2 signal(int,p2);//等同于上个代码
////    return 0;
////}
//int add(int x, int y)
//{
//    return x + y;
//
//}
//int sub(int x, int y)
//{
//    return x - y;
//
//}
//int divide(int x, int y)
//{
//    return x / y;
//}
//int mul(int x, int y)
//{
//    return x * y;
//}
//int main()
//{
//    //int* arr1[6];整形指针数组
//    //char* arr2[5];//字符指针数组
//    
//    //每个元素是函数的地址 函数指针数组
//    int (*pf1)(int, int) = add;
//    int (*pf2)(int, int) = sub;
//    int (*pf3)(int, int) = mul;
//    int (*pf4)(int, int) = divide;
//    int (*pf[4])(int, int) = {add,sub,mul,divide};
//
//    int i = 0;
//    for (i; i < 4; i++)
//    {
//        int ret = (*pf[i])(6, 2);
//        printf("%d ", ret);
//
//    }
//
//    return 0;
//}

//转移表 
//实现一个计算器
//int add(int x, int y)
//{
//    return x + y;
//
//}
//int sub(int x, int y)
//{
//    return x - y;
//
//}
//int divide(int x, int y)
//{
//    return x / y;
//}
//int mul(int x, int y)
//{
//    return x * y;
//}
//void menu()
//{
//    printf("*************************\n");
//    printf("*********1.add 2.sub*****\n");
//    printf("*********3.mul 4.divide*****\n");
//    printf("*********0.exit**********\n");
//    printf("*************************\n");
//    printf("*************************\n");
//    printf("*************************\n");
//    printf("*************************\n");
//
//
//}
//int main()
//{
//    int a = 0;
//    do
//    {
//
//        int x = 0;
//        int y = 0;
//        int (*com[5])(int, int) = { 0,add,sub,mul,divide };
//
//
//        int ret = 0;
//        menu();
//
//
//        printf("请选择：");
//        scanf("%d", &a);
//        // scanf("%d%d", &x, &y);
//        //ret=com[a](x, y);
//        //printf("%d", ret);//这样更简单
//
//        switch (a)
//        {
//
//        case 1:
//            printf("请输入两个数");
//            scanf("%d %d", &x, &y);
//            ret = add(x, y);
//            printf("%d", ret);
//            break;
//
//        case 2:
//
//            scanf("%d %d", &x, &y);
//            ret = sub(x, y);
//            printf("%d", ret);
//            break;
//        case 3:
//
//
//            scanf("%d %d", &x, &y);
//            ret = mul(x, y);
//            printf("%d", ret);
//            break;
//        case 4:
//            scanf("%d %d", &x, &y);
//            ret = divide(x, y);
//            printf("%d", ret);
//            break;
//        case 0:
//            printf("退出");
//            break;
//        default:
//            printf("选择错误 ，重新选择");
//            break;
//        }
//    } while (a);
//
//    return 0;
//int add(int x, int y)
//{
//    return x + y;
//
//}
//int sub(int x, int y)
//{
//    return x - y;
//
//}
//int divide(int x, int y)
//{
//    return x / y;
//}
//int mul(int x, int y)
//{
//    return x * y;
//}
//void menu()
//{
//    printf("*************************\n");
//    printf("*********1.add 2.sub*****\n");
//    printf("*********3.mul 4.divide*****\n");
//    printf("*********0.exit**********\n");
//    printf("*************************\n");
//    printf("*************************\n");
//    printf("*************************\n");
//    printf("*************************\n");
//
//
//}
//
// void Calc(int (*pf)(int,int))//回调函数 
//{
//    int x = 0;
//    int y = 0;
//
//    int ret = 0;
//    printf("请输入两个数");
//    scanf("%d %d", &x, &y);
//    ret = pf(x, y);
//    printf("%d", ret);
//
//}
//int main()
//{
//    int a = 0;
//    do
//    {
//
//       
//        int (*com[5])(int, int) = { 0,add,sub,mul,divide };
//
//        
//        
//        menu();
//
//
//        printf("请选择：");
//        scanf("%d", &a);
//        // scanf("%d%d", &x, &y);
//        //ret=com[a](x, y);
//        //printf("%d", ret);//这样更简单
//
//        switch (a)
//        {
//
//        case 1:
//            Calc(add);
//            break;
//
//        case 2:
//            ; Calc(sub);
//            break;
//        case 3:
//            Calc(mul);
//
//
//          
//            break;
//        case 4:
//            Calc(divide);
//            break;
//        case 0:
//            printf("退出");
//            break;
//        default:
//            printf("选择错误 ，重新选择");
//            break;
//        }
//    } while (a);
//
//    return 0;
//}
//
//void print(int(*p)[5])
//{
//    for (int i = 0;)
//
//
//}
//
//int main()
//{
//
//    int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
//
//    print(arr,);
//
//
//    return 0;
//}

//回调函数是通过函数指针调用的函数




/*nt max1(int x, int y)

{

	int z = 0;

	if (x > y)
	{
		z = x;
	}
	else
	{
		z = y;
	}
	return z;

}

int main()

{



	int a, b, c;

	scanf("%d %d", &a, &b);

	c = max1(a, b);

	printf("max=%d\n", c);

	return 0;

}
*/

//int main()
//{
//    int a = 0;
//    int ret = 0;
//    int b = 1;
//  
//  printf("%d", ret);
//    return 0;
//}
//int main()
//{
//    double s, a, b, c, p;
//    scanf("%lf%lf%lf", &a, &b, &c);
//    p = (a + b + c) / 2;
//   s =sqrt( p*(p - a)*(p - b)*(p - c));
//    printf("%.2f", s);
//
//    return 0;
//}
//int main()
//{
//    double a, b, c;
//    std::cin >> a >> b >> c;
//    printf("%.2f %.2f", (-b + sqrt(b * b - 4 * a * c)) / (2 * a), (-b - sqrt(b * b - 4 * a * c)) / (2 * a));
//
//
//
//
//    return 0;
//}
//void bubble_sort(int arr[], int r)

//void qsort(void* base, size_t num, size_t size,
//    int (*compar)(const void*, const void*));
//void swap(char* f1, char* f2, size_t width)
//{
//    int i = 0;
//    int tmp = 0;
//    //比较两个元素
//    for (i; i < width; i++)
//    {
//        tmp = *f1;
//        *f1 = *f2;
//        *f2 = tmp;
//        f1++;
//        f2++;
//
//    }
// 
// }
//
//void bubble_sort(void * base,size_t sz,size_t width,int(*cmp)(const void*p1,const void*p2))
//{
//    for (int i = 0; i < sz- 1; i++)
//    {
//        for (int j = 0; j <sz - 1 - i; j++)
//        {
//            if (cmp( (char *)base+j*width,(char *)base+(j+1)*width)>0)
//            {
//                /*arr[j] = arr[j] ^ arr[j + 1];
//                arr[j+1]= arr[j] ^ arr[j + 1];
//                arr[j] = arr[j] ^ arr[j + 1];*/
//             /*   int tmp = arr[j];
//                arr[j] = arr[j + 1];
//               
//               
//               arr[j + 1] = tmp;*/
//                //交换两个元素
//                swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
//            }
//
//        }
//
//    }
//
//}
//void print(int arr[], int r)
//{
//    for (int i = 0; i < r; i++)
//    {
//        printf("%d", arr[i]);
//    }
//}
////int main()
////{
////    int arr[10] = { 3,5,4,2,1,9,8,7,10,6 };
////    int sz = sizeof(arr) / sizeof(arr[0]);
////    bubble_sort(arr, sz);
////    print(arr, sz);
////
////    return 0;
////}
////void print(struct student s1[], int r)
////{
////    for (int i = 0; i < r; i++)
////    {
////        printf("%s",s1[i].age);
////    }
////}
//int int_tmp(const void* p1, const void* p2)
//{
//    if (*(int*)p1 - *(int*)p2 > 0)
//    {
//        return 1;
//    }
//    else if (*(int*)p1 - *(int*)p2 < 0)
//    {
//        return -1;
//    }
//    else
//    {
//        return 0;
//    }
//}
//
////struct student
////{
////    int age;
////    char name[20];
////};
////
////int stu_name(const void* p1, const void* p2)
////{
////    //if (((struct student*)p1)->name - ((struct student*)p2)->name > 0)
////    if((*(struct student *)p1).name-(*(struct student*)p2).name>0)
////    {
////        return 1;
////
////  }
////    else if ((*(struct student*)p1).name - (*(struct student*)p2).name < 0)
////
////    {
////        return -1;
////    }
////    else
////    {
////        return 0;
////    }
////}
////int stu_age(const void*p1,const void*p2)
////{
////    /*if ((*(struct student*)p1).age - (*(struct student*)p2).age > 0)
////    {
////        return 1;
////
////    }
////    else if ((*(struct student*)p1).age - (*(struct student*)p2).age < 0)
////
////    {
////        return -1;
////    }
////    else
////    {
////        return 0;
////    }*/
////    //return (*(struct student*)p1).age - (*(struct student*)p2).age;//这么写更简单
////}
//int main()
//{
//    int arr[10] = { 3,5,4,2,1,9,8,7,10,6 };
//     
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    //qsort(arr, sz, sizeof(arr[0]), int_tmp);
//    //print(arr, sz);
//   
//    //struct student s1[] = { {90,"zhangsan"},{30,"wangwei"},{60,"lihua"}};
//    //int sz = sizeof(s1) / sizeof(s1[0]);
//
//    //for (int i = 0; i <= 2; i++)
//    //{
//    //    //printf("%s\n", s1[i].name);
//    //    
//    //}
//    //struct student s2 = { 18,"liuwei" };
//    //struct student* ps1 = &s2;
//   /* printf("%d\n", s2.age);
//    printf("%d\n", (*ps1).age);
//    printf("%d\n", ps1->age);*/
//    //qsort(s1, sz, sizeof(s1[0]), stu_name);
//    //qsort(s1, sz, sizeof(s1[0]), stu_age);
//    bubble_sort(arr, sz, sizeof(arr[0]), int_tmp);
//    print(arr, sz);
//  /*  printf("%s\n", s1[0].name);
//    printf("%s\n", s1[1].name);
//    printf("%s\n", s1[2].name);*/
//    
//    /* print(s1, sz);*/
//    //printf("%d", s1[0].age);
//    //printf("%d", s1[1].age);
//    //printf("%d", s1[2].age);
//
//    return 0;
//
//}
////void qsort(void* base, size_t num, size_t size,
////    int (*compar)(const void*, const void*));

//
//9.11
//void qsort(void* base, size_t num, size_t size,
	////    int (*compar)(const void*, const void*));

//struct student
//{
//    int age;
//    char name[20];
// 
//};
//
//int int_cmp(const void* p1, const void* p2)
//{
//
//    return *(int*)p1 - *(int*)p2;
//}
//
//void swap(char* f1, char* f2, size_t weight)
//{
//    int tmp = 0;
//    for (int i = 0;i < weight;i++)
//    {
//        tmp = *f1;
//        *f1 = *f2;
//        *f2 = tmp;
//        f1++;
//
//        f2++;
//
//
//
//    }
//
//
//}
//void bubble_sort(void* base, size_t sz, size_t weight, int (*cmp)(const void* p1, const void* p2))
//{
//    for (int i = 0; i < sz - 1; i++)
//    {
//
//        for (int j = 0; j < sz - 1 - i; j++)
//        {
//            if (int_cmp((char*)base + j * weight,(char*)base + (j + 1) * weight) > 0)
//            {
//
//                swap((char*)base + j * weight, (char*)base + (j + 1) * weight, weight);
//                //交换
//          }
//
//
//        }
//
//
//
//  }
//
//      
//
//   
//
//
//}
//void print_(int arr[], int sz)
//{
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d\n", arr[i]);
//    }
//
//}void print1_(float arr[], int sz1)
//{
//    for (int i = 0; i < sz1; i++)
//    {
//        printf("%f\n", arr[i]);
//    }
//
//}
//
//int main()
//{
//  int arr[10] = {3,4,5,6,1,2,7,8,9,10};
//  float arr1[6] = { 1.1f,1.2f,1.3f,2.1f,2.2f,2.3f };
//  int  sz = sizeof(arr) / sizeof(arr[0]);
//  int  sz1 = sizeof(arr1) / sizeof(arr1[0]);
//
//    
//    struct student s1[] = { {90,"zhangsan"},{30,"wangwei"},{60,"lihua"}};
//    int sz3 = sizeof(s1) / sizeof(s1[0]);
//    bubble_sort(arr, sz, sizeof(arr[0]), int_cmp);
//    bubble_sort(arr1, sz1, sizeof(arr1[0]), int_cmp);
//    bubble_sort(s1, sz3, sizeof(s1[0]), int_cmp);
//    print_(arr, sz);
//    print1_(arr1, sz1);
//    printf("%d\n", s1[0].age);
//    printf("%d\n", s1[1].age);
//    printf("%d\n", s1[2].age);
//    printf("%s\n", s1[0].name);
//    printf("%s\n", s1[1].name);
//    printf("%s\n", s1[2].name);
//
//
//    return 0;
//}//void qsort(void* base, size_t num, size_t size,
//    ////    int (*compar)(const void*, const void*));


/// int main()
//{
//    int a, b;
//    scanf("%d%d", &a, &b);
//    printf("%d+%d=%d\n", a, b, a + b);
//    printf("%d-%d=%d\n", a, b, a - b);
//    printf("%d*%d=%d\n", a, b, a * b);
//    if (b != 0)
//    {
//        printf("%d/%d=%f\n", a, b, (double)a / (double)b);
//
//
//    }
//    else
//    {
//        printf("%d/%d=error\n", a, b);
//
//
//    } if (b != 0)
//    {
//        printf("%d/%d=%d\n", a, b, a % b);
//
//
//    }
//    else
//    {
//        printf("%d%%%d=error\n", a, b);
//
//
//
//    }
//    return 0;
//}
//int main()
//{
//    int a = 0;
//    scanf("%d", &a);
//    if (a >= 64 && a <= 87)
//    {
//        printf("%c", a + 32);
// }
//    else if (a < 64)
//    {
//        printf("%c", a);
//    }
//    else
//    {
//        printf("%c", a - 32);
//    }
//
//
//    return 0;
//}
//sizeof and strlen
//int main()
//{
//    int a = 10;
//    //printf("%zd", sizeof(int));
//    char arr1[] = { 'a','b','v' };
//    char arr[] = { "abc"};
//    printf("%zd\n", sizeof(arr));
//    printf("%zd\n", sizeof(arr1));
//    printf("%zd\n", strlen(arr1));
//    printf("%zd\n", strlen(arr));
//
//
//   
	//sizeof是操作符，不是函数，单位是字节
	//strlen是库函数 求字符串长度,只能针对字符串(字符数组)
	//统计的是\0之前的字符个数,需要包含头文件

//    return 0;
//}
//数组名是首元素的地址
//两个例外 sizeof &
//int main()
//{
//    int a[] = { 1,2,3,4 };
//
//    printf("%zd\n", sizeof(a));//16
//    //a表示整个数组 计算的是整个数组的大小 单位是字节
//    printf("%zd\n", sizeof(a+0));//4
//    //这里的a是数组名是首元素的地址 不是上面的特例
//    printf("%zd\n", sizeof(*a));//4
//    //a依旧是首元素的地址 *a=arr[0]
//    printf("%zd\n", sizeof(a+1));//
//    //同上 a首元素地址 第二个元素的地址 
//
//    
//    printf("%zd\n", sizeof(a[1]));//
//    //4
//    printf("%zd\n", sizeof(&a));//4
//    //a是整个数组  &a是取出整个数组的地址 是地址 就是4/8个字节 
//    printf("%zd\n", sizeof(*&a));//16
//    //*&a 这里的*和&抵消 ==sizeof(a)
//    printf("%zd\n", sizeof(&a+1));//4
//  //&a+1 跳过整个数组后的那个位置的地址
//    printf("%zd\n", sizeof(&a[0]));//4
//
//    printf("%zd\n", sizeof(&a[0]+1));
//    //第二个元素的地址
//        
//    return 0;
//}

//int main()
//{
//    char arr[] = { 'a','b','c','d','e','f' };
//    printf("%zd\n", sizeof(arr));//6
//    printf("%zd\n", sizeof(arr+0));//4
//    printf("%zd\n", sizeof(*arr));//1 
//    printf("%zd\n", sizeof(arr[1]));//1
//    printf("%zd\n", sizeof(&arr));//4
//    printf("%zd\n", sizeof(&arr+1));//4
//    printf("%zd\n", sizeof(&arr[0]+1));//4
//
//
//
//    return 0;
////}
//
//int main()
//{
//    char arr[] = { 'a','b','c','d','e','f' };
//    printf("%zd\n", strlen(arr));//随机值 记作a
//    printf("%zd\n", strlen(arr+0));//随机值  a
//    ///*有问题*/printf("%zd\n", strlen((const char*)*arr));//arr是首元素地址 'a'--97
//    //传递个strlen strlen会认为97就是地址 然后去访问内存//err
//    //printf("%zd\n", strlen((const char*)arr[1]));
//    //'b'与上面没区别 err
//    printf("%zd\n", strlen((const char*)&arr));//
//    //随机数  a
//    printf("%zd\n", strlen(  (const char*) ( & arr + 1)));//
//    //随机值 a-6
//    printf("%zd\n", strlen(&arr[0]+1));//
//    //随机值 a-1
//
//
//    return 0;
//}
//int main()
//{
//    
//
//    char arr[] = {"abcdef"};
//        printf("%zd\n", sizeof(arr));//7
//        printf("%zd\n", sizeof(arr+0));//4
//        printf("%zd\n", sizeof(*arr));//1
//        printf("%zd\n", sizeof(arr[1]));//1
//        printf("%zd\n", sizeof(&arr));//4
//        printf("%zd\n", sizeof(&arr+1));//4
//        printf("%zd\n", sizeof(&arr[0]+1));//4
//    return 0;
//}

//int main()
//{
//    
//
//    char arr[] = {"abcdef"};
//        printf("%zd\n", strlen(arr));//6
//        printf("%zd\n", strlen(arr+0));//6 
//        //printf("%zd\n", strlen(*arr));//err
//        //printf("%zd\n", strlen(arr[1]));//err
//        printf("%zd\n", strlen((const char*) &arr));//6
//        printf("%zd\n", strlen((const char *) & arr + 1));//随机数
//        printf("%zd\n", strlen(&arr[0]+1));//5
//    return 0;
//}
//int main()
//{
//  const char* p = "abcdef";
//
//  printf("%zd\n", sizeof(p));//4/8
//  printf("%zd\n", sizeof(p+1));//4/8
//  printf("%zd\n", sizeof(*p));//1 p的类型是char *所以只能访问一个字节
//  printf("%zd\n", sizeof(p[0]));//p[0]=*(p+0)->p
//  printf("%zd\n", sizeof(&p));//4/8
//  //&p char **二级指针 
//  
//  printf("%zd\n", sizeof(&p+1));//4/8
////跳过p变量 指向了p的后边 
//
//  printf("%zd\n", sizeof(&p[0]+1));//4/8
//  //&p[0]=p
//  return 0;
//}
//int main()
//{
//    const char* p = "abcdef";
//    printf("%zd\n", strlen(p));//6
//    printf("%zd\n", strlen(p+1));//5
//    //printf("%zd\n", strlen(*p));////a err
//    //printf("%zd\n", strlen(p[0]));//err
//    printf("%zd\n", strlen((const char*)&p));//随机值 
//    printf("%zd\n", strlen((const char*) & p + 1));//随机值
//    printf("%zd\n", strlen(&p[0]+1));//5
//
//    return 0;
//}
//二维数组 
//int main()
//{
//    int a[3][4] = { 0 };
//    printf("%zd\n", sizeof(a));
//    //a作为数组名 放在sizeof里边 a表示的是整个数组 3*4*4=48
//
//    printf("%zd\n", sizeof(a[0][0]));
//    // 4 a[0][0]=0
//
//    printf("%zd\n", sizeof(a[0]));
//    //a[0]代表第一行的数组名 单独放在sizeof 4*4=16
//    printf("%zd\n", sizeof(a[0] + 1));
//  //a[0]没有单独放在sizeof中 表示首元素的地址 a[0][0]的地址 &a[0][1] 4/8
//    printf("%zd\n", sizeof(*(a[0] + 1)));
//    //第一行第二个元素  大小是四个字节 
//    printf("%zd\n", sizeof(a + 1));
//    // a没有单独放在sizeof中  表示首元素的地址 也就是第一行的地址 
//    // &a[0]->&a[1] 4/8
//
//    printf("%zd\n", sizeof(*(a + 1)));
//   // a+1->&a[1] *&a[1]=a[1] 第二行的数组名单独放在sizeof中 
//    //*&抵消了
//    printf("%zd\n", sizeof(&a[0] + 1));
//    //&a[1]  4/8
//    printf("%zd\n", sizeof(*(&a[0] + 1)));
//    // a[1] 4*4 
//    printf("%zd\n", sizeof(*a));
//     //  a表示 首元素的地址 &a[0]->a[0]
//
//    //4*4
//    printf("%zd\n", sizeof(a[3]));
//    //越界了吗? 
//    //sizeof内部的表达式不会真实计算的 
//    //a[3] 第四行的数组名 int[4] 4*4
//
//    return 0;
//}
//int main()
//{
//    short s = 8;
//    int n = 12;
//    printf("%d\n", sizeof(s = n + 5));
//    //最终结果取决于short 
//    printf("%d\n", s+1);
//
//    return 0;
//}
//int main()
//{
//
//    int a[5] = { 1,2,3,4,5 };
//    int* ptr = (int*)(&a + 1);
//    printf("%d,%d", *(a + 1), *(ptr - 1));
//    //                   2        5
//    return 0;
//}
//在x86环境下 
//假设结构体的大小是20个字节 
//程序输出的结果是 
//struct Test
//{
//
//    int Num;
//    char* pcname;
//    short sdate;
//    char cha[2];
//    short sba[4];
//}*p = (struct Test*)0x100000;
//int main()
//{
//    printf("%p\n",p + 1);
//    //指针＋1是跳过一个类型 取决于类型 
//    //数字 +1就是加1
//    //p是结构体指针 跳过一个结构体 20个字节 但是是十六进制 0x100014;
//    printf("%p\n", (unsigned long)p + 1);
//    //unsigned long 类型的 +1就是+1 0x100001
//    printf("%p\n", (unsigned int*)p + 1);
//    //跳过一个 unsignedint类型的 4个字节 0x100004
//    return 0;
//}
//int main()
//{
//    int a[3][2] = { (0,1),(2,3),(4,5) };//用的是（）所以 为逗号表达式 1,3,5
//    //0,0,0,      1,3 5,0 0,0 正常来说应该用的是 {}
//    int* p;
//
//    p = a[0];//&a[0]  
//    printf("%d", p[0]);//1 ?
//    //p[0]==*(p+0) 
//    int arr[5] = { 0 };
//    arr[1] = *(arr + 1);
//     
//    return 0;
//}
//x86
//int main()
//{
//    int a[5][5];
//    int(*p)[4];
//    p = a;
//    
//
//    printf("%p,%d", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//    //p[4]=*(p+4)             -4                   -4  
//    //10000000000000000000000000000100
//    //11111111111111111111111111111011
//    //11111111111111111111111111111100
//      //FF FF FF FC 16进制 
//    return 0;
//}
/*nt main()
{
	printf("%p", -4);

	return 0;
}*/  //对应上面的 
//int main()
//{
//    int aa[2][5] = { 1,2,3,4,5,6,7,8,9,10 };
//    int* ptr1 = (int*)(&aa + 1);
//    int* ptr2 = (int*)(*(aa + 1));
// aa+1 第二行元素的地址  -> * ->  aa[2]  数组名表示首元素的地址 
//    printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
//    // 10                               5
//
//    return 0;
//}
//int main()
//{
//     const char* a[] = { "work","at","alibaba" };
//                        //w地址  a地址  a地址 指针数组
//  const  char** pa = a;
//
//    pa++;
//    printf("%s\n", *pa);
//    //*pa 是地址 
//    return 0;
//}
//int main()
//{
//     const char* c[] = { "enter","new","point","first" };
//     const char** cp[] = { c + 3,c + 2,c + 1,c };
//     const char*** cpp = cp;
//     printf("%s\n", **++cpp);
//     //** ++ cpp point 
//     printf("%s\n", *-- * ++cpp + 3);
//     //最后算+
//     printf("%s\n", *cpp[-2] + 3); 
//     //cpp[-2]=*(cpp-2)
//     printf("%s\n", cpp[-1][-1] + 1);
//     const char* p = "work";
//     printf("%s\n", p + 2);//rk
//     printf("%d\n", *p);//w
//
//     return 0;
//}
//int main()
//{
//    int a = 0;
//    printf("%d", a++);
//    printf("%d", ++a);
//    printf("%d", ++a);
//    //++a是会自增的 之后加了1
//
//
//}
//.内存中每个字节都有地址，地址可以唯一标识一个内存单元的
//C语言中地址就是指针，指针就是地址
//内存中每个字节都有唯一的地址 
//野指针无法使用 
//int main()
//{
//    int arr[] = { 1,2,3,4,5 };
//    short* p = (short*)arr;
//    int i = 0;
//    for (i = 0; i < 4; i++)
//    {
//        *(p + i) = 0;
//        //p[i]
//    }
//
//    for (i = 0; i < 5; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    return 0;
//}
////arr数组在内存中的存储格式为：
//0x00ECFBF4:  01 00 00 00
//0x00ECFBF8 : 02 00 00 00
//0x00ECFBFC : 03 00 00 00
//0x00ECFC00 : 04 00 00 00
//0x00ECFC04 : 05 00 00 00
//指针p的类型为short * 类型的，因此p每次只能所有两个字节，for循环对数组中内容进行修改时，一次访问的是：
//arr[0]的低两个字节，arr[0]的高两个字节，arr[1]的低两个字节，arr[1]的高两个字节，故改变之后，数组中内容如下：
//0x00ECFBF4 : 00 00 00 00
//0x00ECFBF8 : 00 00 00 00
//0x00ECFBFC : 03 00 00 00
//0x00ECFC00 : 04 00 00 00
//0x00ECFC04 : 05 00 00 00
//故最后打印：0   0   3   4   5
//
//
//int main()
//{
//    double a = 3.0;
//    printf("%lf", a);
//    printf("%lf2", a);
//
//
//    return 0;
//}
//int main()
//{
//    int a[5][5];
//    int(*p)[4];
//    p = a;
//    
//
//    printf("%p,%d", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
//    //p[4]=*(p+4)             -4                   -4  
//    //10000000000000000000000000000100
//    //11111111111111111111111111111011
//    //11111111111111111111111111111100
//      //FF FF FF FC 16进制 
//    return 0;
//}
//int main()
//{
//
//    unsigned long pulArray[] = { 6,7,8,9,10 };
//    unsigned long* pulPtr;
//    pulPtr = pulArray;
//    *(pulPtr + 3) += 3;
//    printf("%d,%d\n", *pulPtr, *(pulPtr + 3));
//
//    return 0;
//}
//指针可以比较大小
//将一个字符串str的内容颠倒过来，并输出。
//
//数据范围：


//1≤len(str)≤10000
//
//输入描述 :
//输入一个字符串，可以有空格
//
//
//
//输出描述:
//输出逆序的字符串
//void reverse(char* p, int a)
//{
//    int r = 0;
//    for (r; r < a; r++)
//    {
//
//
//        printf("%c", *(p + a-r-1));
//
//
//    }
//    
//
//
//}
//int main()
//{
//    char arr[10000] = { 0 };
//    std::cin >> arr;
//    int sz = strlen(arr);
//    reverse(arr,sz);
//
//    return 0;
//}//只能倒序没有空格的 所以应该先把字符串反过来 再打印 
//void reverse(char* p, int a)
//{
//    char* right = p + (a - 1);
//    while (p < right)
//    {
//        char c = *p;
//        *p = *right;
//        *right = c;
//        p++;
//        right--;
//
//    }
//
//
//
//
//}
//int main()
//
//{
//    char arr[10000];
//   
//    while (gets(arr))
//    {
//        int sz = strlen(arr);
//        reverse(arr, sz);
//        printf("%s\n", arr);//gets在c语言中可行 c++中无法识别 
//    }
//    return 0;
//}
//以下哪个操作可以避免野指针的出现？
//
//
//A.使用空指针（NULL）初始化指针变量
//B.在指针释放后将其设置为NULL
//C.确保指针始终指向有效的内存地址
//D.检查指针的有效性后再进行访



//实现一个函数，可以左旋字符串中的k个字符。
//
//
//
//例如：
//
//
//
//ABCD左旋一个字符得到BCDA
//
//ABCD左旋两个字符得到CDAB

//
//void leftround(char* src, int time)
//{
//    int len = strlen(src);
//    time %= len;
//    
//    int tmp;
//    int i;
//    int j;
//    for ( i = 0; i < time; i++)
//    {
//        tmp = src[0];
//        for ( j = 0; j < len - 1; j++)
//        {
//            src[j] = src[j + 1];
//
//        }
//        src[j] = tmp;
//    }
//

//}
//for 循环中嵌套int类型 此时局部变量只作用于for循环内部 出了for循环 就会被摧毁 这就是上述错误的地方 在最后src[j]=tmp处 如果放上类型名int 上面还得定义int j=0 此时j视为0

//int main()
//{
//    int i = 0;
//    for (int i = 0; i <= 5; i++)
//    {
//        printf("%d\n", i);//0 1 2 3 4 5
//
//    }
//    printf("%d\n", i);  //0
//    int j = 0;
//    for ( j = 0; j <= 5; j++)
//    {
//        printf("%d\n", j);//0 1 2 3 4 5
//
//    }
//    printf("%d\n",j);//6
//
//
//}


//
// 
// 
// 
//void leftRound(char* src, int time) 
//{
//    int i, j, tmp;
//    int len = strlen(src);
//    time %= len; //长度为5的情况下，旋转6、11、16...次相当于1次，7、12、17...次相当于2次，以此类推。
//    for (i = 0; i < time; i++) //执行k次的单次平移
//    {
//        tmp = src[0];
//        for (j = 0; j < len - 1; j++) //单次平移
//        {
//            src[j] = src[j + 1];
//        }
//        src[j] = tmp;
//    }
//} int main()
//    {
//    char arr[10] = "abcdefg";
//    char arr1[10] = "abcdefg";
//    leftRound(arr, 2);
//    printf("%s\n", arr);
//
//    leftround(arr1, 2);
//    printf("%s\n", arr1);
//
//        return 0;
//    }
//int main()
//{
//    char str[] = "abcdef";
//    char copy[256] = { 0 };
//    strcpy(copy, str);
// 
// 
//   //字符串的拷贝函数 strcpy
// 从开始到\0拷贝
//   printf("%s\n", copy);
//    char str1[] = "abcdef";
//    char cat[256] = "abc";
//    char cat1[256] = "abc";
//    strcat(cat, str1);
//    strncat(cat1, str1,2);
//   //从str指向的位置开始 拼接 n个字符到cat的最后 
//    printf("%s\n", cat);
//    printf("%s\n", cat1);
//    //字符串的拼接 
//    return 0;
//}
//void leftround(char* pa, int time)
//{
//    char tmp[100000];
//    strcpy(tmp, pa + time);
//    strncat(tmp, pa, time);
//    strcpy(pa, tmp);
//}
//int main()
//{
//    char arr[10] = { "abcdef" };
//    int k;
//    scanf("%d", &k);
//    int len = strlen(arr);
//    int time = k % len;
//    leftround(arr, time);
//    printf("%s\n", arr);
//    return 0;
//}
//模拟库函数实现strlen
//int mystrlen(char* c)
//{
//    int i = 0;
//    while (*c)
//    {
//        c++;
//
//        i++;
//    }
//    return i;
//}
//int main()
//{
//    char arr[1000];
//    std::cin >> arr;
//    int ret = mystrlen(arr);
//        printf("%d", ret);
//        return 0;
//
//}
// void reverse_part(char *str, int start, int end) //将字符串从start到end这一段逆序
//{
//    int i, j;
//    char tmp;
//
//    for (i = start, j = end; i < j; i++, j--)
//    {
//        tmp = str[i];
//        str[i] = str[j];
//        str[j] = tmp;
//    }
//}
//
//void leftRound(char* src, int time)
//{
//    int len = strlen(src);
//    int pos = time % len;
//    reverse_part(src, 0, pos - 1); //逆序前段
//    reverse_part(src, pos, len - 1); //逆序后段
//    reverse_part(src, 0, len - 1); //整体逆序
//}
//调整数组使奇数全部都位于偶数前面。
//
//
//
//题目：
//
//输入一个整数数组，实现一个函数，
//
//来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，
//
//所有偶数位于数组的后半部分。
//
//void change(int * pa, int a)
//{
//    int i = 0;
//    int j = a - 1;
//    while (i <= j)
//    {
//        if (*pa % 2 == 1)
//        {
//
//            pa = pa+a-1;
//            pa++;
//            i++;
//        }
//
//        
//        if (*pa % 2 == 0)
//        {
//            pa[j] = *pa;
//            pa++;
//            j--;
//        }
//
//    }
//}
//int main()
//{
//    //int arr[1000];
//    //std::cin >> arr；//err cin不可以输入整形数组 
//    int arr[] = { 2,4,5,8,4,6,7,6,8,9,10,2,5,4 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    change(arr, sz);
//    for (int j = 0; j < sz; j++)
//    {
//        printf("%d ", arr[j]);
//
//   }
//
//
//    return 0;
//}大错特错 

//void change(int arr[] ,int a)
//{
//    int left = 0;
//    int right = a - 1;
//    int tmp;
//    while (left < right)
//    {
//        if (left < right&&arr[left] % 2 == 0)
//        {
//            if (left < right&&arr[right] % 2 == 1)
//            {
//                tmp = arr[left];
//                arr[left] = arr[right];
//                arr[right] = tmp;
//            }
//            else
//            {
//                right--;
//            }
//        }
//        else
//        {
//            left++;
//        }
//    }
//
//
//}
//void swap_arr(int arr[], int sz)
//{
//    int left = 0;
//    int right = sz - 1;
//    int tmp = 0;
//
//
//    while (left < right)
//    {
//        // 从前往后，找到一个偶数，找到后停止
//        while ((left < right) && (arr[left] % 2 == 1))
//        {
//            left++;
//        }
//
//        // 从后往前找，找一个奇数，找到后停止
//        while ((left < right) && (arr[right] % 2 == 0))
//        {
//            right--;
//        }
//
//        // 如果偶数和奇数都找到，交换这两个数据的位置
//        // 然后继续找，直到两个指针相遇
//        if (left < right)
//        {
//            tmp = arr[left];
//            arr[left] = arr[right];
//            arr[right] = tmp;
//        }
//    }
//}
//void printarr(int arr[], int a)
//{
//    for (int i = 0; i < a; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//}
//int main()
//{
//    //int arr[1000];
//    //std::cin >> arr；//err cin不可以输入整形数组 
//    int arr[] = { 2,4,5,8,4,6,7,6,8,9,10,2,5,4 };
//    int arr1[] = { 2,4,5,8,4,6,7,6,8,9,10,2,5,4 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    change(arr, sz);
//    printarr(arr, sz); 
//    printf("\n");
//    swap_arr(arr1, sz);
//    printarr(arr1, sz);
//
//    return 0;
//}
//#include <stdio.h>
//int main()
//{
//    int* p = NULL;
//    int arr[10] = { 0 };
//    return 0;
//   int(*p) [10] = &arr;
//}
//写一个函数打印arr数组的内容，不使用数组下标，使用指针。
//
//arr是一个整形一维数组。
//void print(int* a, int r)
//{
//    for (int i = 0; i < r; i++)
//    {
//        printf("%d ", a[i]);
//    }
//}
//int main()
//{
//    int arr[] = { 1,2,3,4,5,4 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//
//    print(arr, sz);
//
//    return 0;
//}
//实现一个对整形数组的冒泡排序
//int int_cmp(const void* p1, const void* p2)
//{
//    return *(int *)p1 - *(int *)p2;
//
//}
//void print(int arr[], int a)
//{
//    for (int i = 0; i < a; i++)
//    {
//
//
//        printf("%d ", arr[i]);
//    }
//}
//
//int main()
//{
//    int arr[] = { 2,5,3,4,8,7,6,10,11,9 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    qsort(arr, sz, sizeof(arr[0]), int_cmp);
//    print(arr, sz);
//
//    return 0;
/*void qsort(void* base, size_t num, size_t size,
	int (*compar)(const void*, const void*));*/
	//void print(int arr[], int a);
	//void bubble_sort(int arr[], int a)
	//{
	//    for (int i = 0; i < a - 1; i++)
	//    {
	//        int tmp = 0;
	//        for (int j = 0; j < a - 1 - i; j++)
	//        {
	//            if (arr[j] >arr[j + 1])
	//            {
	//                tmp = arr[j];
	//                arr[j] = arr[j + 1];
	//                arr[j + 1] = tmp;
	//
	//            }
	//
	//        }
	//
	//    }
	//}
	//int main()
	//{
	//   
	//    int arr[] = { 2,5,3,4,8,7,6,10,11,9 };
	//     int sz = sizeof(arr) / sizeof(arr[0]);
	//     bubble_sort(arr, sz);
	//     print(arr, sz);
	//    return 0;
	//}
	//void print(int arr[], int a)
	//{
	//    for (int i = 0; i < a; i++)
	//    {
	//
	//
	//        printf("%d ", arr[i]);
	//    }
	//}//函数指针 
	//int add(int x, int y)
	//{
	//    return x + y;
	//}
	//
	//int main()
	//{
	//    int (*padd)(int, int) = add;
	//    int ret=padd(3, 4);
	//    printf("%d", ret);
	//
	//    return 0;
	// }

	//int main()
	//{
	//    printf("%d 4", 2);
	//
	//
	//    return 0;
	//}

	// 
	// 
	//写一个函数，判断一个字符串是否为另外一个字符串旋转之后的字符串。
	//
	//
	//
	//例如：给定s1 = AABCD和s2 = BCDAA，返回2
	//
	//给定s1 = abcd和s2 = ACBD，返回0.
	//
	//
	//
	//AABCD左旋一个字符得到ABCDA
	//
	//AABCD左旋两个字符得到BCDAA
	//
	//AABCD右旋一个字符得到DAABC
	//int leftround(char* p, char *p2,int len)
	//{
	//    int time;
	//    for (time = 0; time<len; time++)
	//    {
	//
	//
	//        char tmp[100000];
	//        strcpy(tmp, p + time);
	//        strncat(tmp, p, time);
	//      
	//        if (tmp == p2)//这里是地址 即使字符串相同 也不相等 因为地址不同 
	//        {
	//            return time;
	//         
	//        }
	//       
	//    }
	//    return 0;
	//}
	//int main()
	//{
	//    char arr1[] = "abcdef";
	//    char arr2[] = "bcedfa";
	//   
	//    int len = strlen(arr1);
	//    int ret=leftround(arr1, arr2,len);
	//    printf("%d", ret);
	//    return 0;
	//}
	////void leftround(char* pa, int time)
	////{
	////    char tmp[100000];
	////    strcpy(tmp, pa + time);
	////    strncat(tmp, pa, time);
	////    strcpy(pa, tmp);
	////}
	//int main()
	//{
	//    const char* str1 = "abccd";
	//  const char* str2 = "bc";
	//const char* ret = strstr(str1, str2);
	//printf("%s\n", ret);
	////strstr(a,b)          strstr是指在a中寻找b从b的首字符开始打印字符串
	//    return 0;
	//}
	//char* func(char* p1, char* p2)
	//{
	//    char tmp[20000];
	//    strcpy(tmp, p1);
	//    strcat(tmp, p1);
	//    
	//    
	//    return strstr(tmp, p2);
	//}
	////int findRound(const char* src, char* find)
	////{
	////    char tmp[256] = { 0 }; //用一个辅助空间将原字符串做成两倍原字符串
	////    strcpy(tmp, src); //先拷贝一遍
	////    strcat(tmp, src); //再连接一遍
	////    return strstr(tmp, find) != NULL; //看看找不找得到
	////}
	//int main()
	//{
	//    char arr1[] = "abcdef";
	//    char arr2[] = "bcdefa";
	//    //int len = strlen(arr1);
	//  /*  int ret=findRound(arr1, arr2);*/
	//   char *ret= func(arr1, arr2);
	//    //printf("%d", ret);
	//   if (ret = NULL)
	//   {
	//       printf("%d", 0);
	//   }
	//   else
	//   {
	//       printf("%d", 1);
	//   }
	//
	//    return 0;
	//}
	//判断两个字符串是否相等 strcmp
	//int func2(char* p1, char* p2,int a)
	//
	//{
	//    int time = 0;
	//    while (time < a)
	//    {
	//        char tmp[100000];
	//        strcpy(tmp, p1+ time);
	//        strncat(tmp, p1,time);
	//        //      
	//        if (strcmp(tmp, p2)!=0)
	//        {
	//            return 1;
	//          
	//        }
	//        else
	//        {
	//            time++;
	//        }
	//       
	//
	//    }
	//    return 0;
	//}
	//int main()
	//{
	//    char arr1[] = "abcdef";
	//   char arr2[] = "bcdefa";
	//   int len = strlen(arr1);
	//   int ret=func2(arr1, arr2,len);
	//   printf("%d", ret);
	//    return 0;
	//}
	//有一个数字矩阵，矩阵的每行从左到右是递增的，矩阵从上到下是递增的，请编写程序在这样的矩阵中查找某个数字是否存在。
	//
	//
	//
	//要求：时间复杂度小于O(N);
	//int findcount(int(* arr)[3],int find)
	//{/*
	//    for (int i = 0; i < 3; i++)
	//    {
	//        for (int j = 0; j < 3; j++)
	//        {
	//
	//            if (*(a+i)[j] == find)
	//            {
	//                printf("存在");
	//               
	//            }
	//
	//         
	//        }
	//    }*///这个时间复杂度等于 on 不行 
	//    int i = 0;
	//    int j = 2;
	//    while ((i<3)&&(j>=0))
	//    {
	//        if (arr[i][j] < find)
	//        {
	//            i++;
	//        }
	//        else if (arr[i][j] > find)
	//        {
	//            j--;
	//        }
	//        else
	//        {
	//            return 1;
	//        }
	//        
	//    }
	//
	//    return 0;
	//
	//}
	//
	//int main()
	//{
	//    int arr[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
	//   int ret= findcount(arr,9);
	//   if (ret == 1)
	//   {
	//       printf("zhao dao l");
	//   }
	//   else
	//   {
	//       printf("mei you zhao dao");
	//   }
	//
	//
	//    return 0;
	//}
	//#include <stdio.h>

	//int findnum(int a[][3], int x, int y, int f) //第一个参数的类型需要调整
	//{
	//    int i = 0, j = y - 1; //从右上角开始遍历
	//    while (j >= 0 && i < x)
	//    {
	//        if (a[i][j] < f) //比我大就向下
	//        {
	//            i++;
	//        }
	//        else if (a[i][j] > f) //比我小就向左
	//        {
	//            j--;
	//        }
	//        else
	//        {
	//            return 1;
	//        }
	//    }
	//    return 0;
	//}
	//
	//int main()
	//{
	//    int a[][3] = { {1, 3, 5},
	//                  {3, 5, 7},
	//                  {5, 7, 9} }; //一个示例
	//
	//    if (findnum(a, 3, 3, 2))
	//    {
	//        printf("It has been found!\n");
	//    }
	//    else
	//    {
	//        printf("It hasn't been found!\n");
	//    }
	//
	//    return 0;
	//}
	//日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
	//
	//
	//
	//以下为4个嫌疑犯的供词:
	//
	//
	//
	//A说：不是我。
	//
	//B说：是C。
	//
	//C说：是D。
	//
	//D说：C在胡说
	//
	//已知3个人说了真话，1个人说的是假话。
	//
	//
	//
	//现在请根据这些信息，写一个程序来确定到底谁是凶手。

	//void findkiller()
	//{
	//    char killer = 'a';
	//    for ( killer; killer <= 'd'; killer++)
	//    {
	//        if ((killer != 'a') +( killer == 'c') + (killer == 'd' )+( killer != 'd' )== 3)
	//        {
	//            printf("%c ", killer);
	//        }
	//
	//
	//    }
	//
	//}
	//
	//
	//int main()
	//{
	//    //1为真 0为假
	//    findkiller();
	//    return 0;
	//}
	//在屏幕上打印杨辉三角。
	//
	//
	//
	//1
	//
	//1 1
	//
	//1 2 1
	//
	//1 3 3 1
	//
	//……
	//int count(int a)
	//{
	//    int ret=1;
	//    for (int i = 1; i <= a; i++)
	//    {
	//        ret =ret * i;
	//    }
	//    return ret;
	//}
	//
	//int Cncount(int i,int j)
	//{
	//    return count(i) / count(j)/count(i-j);
	//
	//}
	//
	//
	//
	//void printcount()
	//{
	//    printf("%d\n", 1);
	//   
	//    for (int i = 1; i<i+1; i++)
	//    {
	//        int ret = 0;
	//        for (int j = 0; j <= i; j++)
	//        {
	//           ret= Cncount(i, j);
	//           printf("%d ", ret);
	//        }
	//      
	//        printf("\n");
	//
	//    }
	//
	//
	//
	//}
	//int main()
	//{
	//    printcount();
	//
	//}



	//
	//int main()
	//{
	//    for (int i = 0; i < i + 1; i++)
	//    {
	//        printf("hello");
	//    }
	//
	//
	//
	//    return 0;
	//}

	//#include<stdio.h>
	//int main()
	//{
	//    int i = 1, ret = 1, n = 0;//定义变量并给i,ret赋值
	//    scanf("%d", &n);//输入阶乘数
	//    for (; i <= n; i++) 
	//    {//for循环的结构，第一个分号前为赋值语句，中间为判断语句，一旦条件不达标，结束循环，第三个给可以是递增也可以是递减，i++或者i--操作，也可以是++i或者--i等等，三个语句中语句一和语句三可以用空语句代替，但是语句二要有，语句一的赋值可以放在for循环的外面，而语句三可以放在花括号里面，代码中的for循环就是省略了赋值语句用分号;代替是可以的，在循环外面i已经赋值为1了
	//        ret *= i;
	//
	//
	//        //c语言%d是输出的一种格式表示输出的是一个整数，而前面的ret也是整型
	//    }
	//    printf("%d的阶乘为%d", n, ret);
	//        return 0;
	//    
	//
	//}
	//    
	//int main()
	//{
	//    int i = 0;
	//    int ret = 1;
	//    for (i = 1; i < 5; i++)
	//    {
	//
	//        ret *= i;
	//        printf("%d ", ret);
	//
	//    }
	//    printf("%d ", ret);
	//    return 0;
	//}

	//void yangHuiTriangle(int n)
	//{
	//    int data[30][30] = { 1 }; //第一行直接填好，播下种子
	//
	//    int i, j;
	//
	//    for (i = 1; i < n; i++) //从第二行开始填
	//    {
	//        data[i][0] = 1; //每行的第一列都没有区别，直接给1，保证不会越界。
	//        for (j = 1; j <= i; j++) //从第二列开始填
	//        {
	//            data[i][j] = data[i - 1][j] + data[i - 1][j - 1]; //递推方程
	//        }
	//    }
	//
	//    for (i = 0; i < n; i++) //填完打印
	//    {
	//        for (j = 0; j <= i; j++)
	//        {
	//            printf("%d ", data[i][j]);
	//        }
	//        putchar('\n');
	//    }
	//}
	//int main()
	//{
	//
	//    yangHuiTriangle(4);
	//}
	//void yangHuiTriangle(int n)
	//{
	//    int data[30] = { 1 };
	//
	//    int i, j;
	//    printf("1\n"); //第一行就直接打印了
	//    for (i = 1; i < n; i++) //从第二行开始
	//    {
	//        for (j = i; j > 0; j--) //从后向前填，避免上一行的数据在使用前就被覆盖
	//        {/*
	//            printf("%d ", data[1]);
	//            printf("%d ", data[0]);
	//            printf("%d ", data[2]);*/
	//            
	//            data[j]=data[j]+data[j-1]; //公式同上，由于变成了一维，公式也变简单了。
	//        }
	//
	//        for (j = 0; j <= i; j++)// //这一行填完就直接打印了。
	//        {
	//            printf("%d ", data[j]);
	//        }
	//        putchar('\n');
	//    }
	//}
	//int main()
	//{
	//    yangHuiTriangle(4);
	//
	//    return 0;
	//}
	//下面哪个是数组指针（   ）
	//
	//
	//作业内容
	//A.int** arr[10]
	//B.int(*arr[10])
	//C.char* (*arr)[10]
	//D.char(*)arr[10]
	//c  是数组指针 指向的每个元素类型 是char*
	//定义一个函数指针，指向的函数有两个int形参并且返回
	// 一个函数指针，返回的指针指向一个有一个int形参且返回int的函数？下面哪个是正确的？（   ）

	//int (*)(int) (*F)(int, int);
	//A.int (*(*F)(int, int))(int)
	//B.int (*F)(int, int)
	//C.int(*(*F)(int, int))
	//D.*(*F)(int, int)(int)


	//课堂上所讲使用函数指针数组实现转移表的代码，自己实践后，并提交代码到答案窗口。
	//int add(int x, int y)
	//{
	//    return x + y;
	//}
	//int sub(int x, int y)
	//{
	//    return x - y;
	//}
	//int mul(int x, int y)
	//{
	//    return x * y;
	//}
	//int divide(int x, int y)
	//{
	//    return x / y;
	//}
	//
	//int main()
	//{
	//    int(*func1[5])(int ,int ) = {0,add,sub,mul,divide};
	//    printf("*******menu*********\n");
	//    printf("*****0.exit************\n");
	//    printf("*****1.add 2.sub*******\n");
	//    printf("*****3.mul 4.divide***\n");
	//    printf("*********************\n");
	//    printf("*********************\n");
	//    printf("*********************\n");
	//    int a;
	//    int x;
	//    int y;
	//    scanf("%d ", &a);
	//    scanf("%d%d", &x, &y);
	//    int ret = func1[a](x, y);
	//    
	//    
	//    
	//    printf("%d ", ret);
	//
	//
	//    return 0;
	//}
	//一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。
	//
	//编写一个函数找出这两个只出现一次的数字。
	//
	//
	//
	//例如：
	//
	//有数组的元素是：1，2，3，4，5，1，2，3，4，6
	//
	//只有5和6只出现1次，要找出5和6.

	//void findarr(int arr[], int a, int* key1, int* key2)
	//{
	//    // 1.所有元素^ 2.判断哪一位是1 3.分组进行^
	//
	//    int b;
	//
	//    for (int i = 0; i < a; i++)
	//    {
	//        b ^= arr[i];
	//    }
	//    //1
	//    int j = 0;
	//    int pos;
	//    for (; j < 32; j++)
	//    {
	//        if (((b >> j) & 1) == 1)
	//        {
	//            pos = j;
	//            break;
	//        }
	//    }
	//
	//
	//    for (int i = 0; i < a; i++)
	//    {
	//        if (((arr[i] >> pos) & 1) == 1)
	//        {
	//            *key1 ^= arr[i];
	//        }
	//        else
	//        {
	//            *key2 ^= arr[i];
	//        }
	//
	//
	//    }
	//
	//
	//}
	//int main()
	//
	//
	//{
	//    int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
	//    int sz = sizeof(arr) / sizeof(arr[0]);
	//    int a = 0;
	//    int b = 0;
	//    findarr(arr, sz, &a, &b);
	//    //传址调用  
	//    printf("%d %d", a, b);
	//    return 0;
	//}
	////void findTwoNum(int arr[], int n, int* pnum1, int* pnum2)
	//{
	//    int i;
	//    int sum = 0;
	//    ​
	//        for (i = 0; i < 9; i++)
	//        {
	//            sum ^= arr[i];
	//        } //先找到两个数互相异或的结果
	//    ​
	//        int pos;
	//    for (i = 0; i < 32; i++)
	//    {
	//        if (sum & 1 << i)
	//        {
	//            pos = i;
	//            break;
	//        }
	//    } //再找到有分歧的一位。在这一位上，两个数一定是一个1一个0
	//    ​
	//        * pnum1 = *pnum2 = 0;
	//    for (i = 0; i < 10; i++)
	//    {
	//        if (arr[i] & 1 << pos)
	//        {
	//            *pnum1 ^= arr[i]; //这一位是1的，放在数1里
	//        }
	//        else
	//        {
	//            *pnum2 ^= arr[i]; //这一位是0的，放在数2里
	//        }
	//    }
	//}
	//int main()
	//{
	//    int arr[] = { 1,2,1,2,3 };
	//    int tmp = 0;
	//    for (int i = 0; i < 5; i++)
	//    {
	//        tmp ^= arr[i];
	//    }
	//    printf("%d ", tmp);
	//    return 0;
	//}
	//void findarr(int arr[], int a)
	//{
	//    // 1.所有元素^ 2.判断哪一位是1 3.分组进行^
	//
	//    int b;
	//
	//    for (int i = 0; i < a; i++)
	//    {
	//        b ^= arr[i];
	//    }
	//    //1
	//    int j = 0;
	//    int pos;
	//    for (; j < 32; j++)
	//    {
	//        if (((b >> j) & 1) == 1)
	//        {
	//            pos = j;
	//            break;
	//        }
	//    }
	//
	//    int key1=0;
	//    int key2=0;
	//    for (int i = 0; i < a; i++)
	//    {
	//        if (((arr[i] >> pos) & 1) == 1)
	//        {
	//            key1 ^= arr[i];
	//        }
	//        else
	//        {
	//            key2 ^= arr[i];
	//        }
	//
	//
	//    }
	//
	//    printf("%d %d ", key1, key2);
	//}
	//int main()
	//
	//
	//{
	//    int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
	//    int sz = sizeof(arr) / sizeof(arr[0]);
	//    findarr(arr, sz);
	//    //传址调用  
	//    return 0;
	//}
	//KiKi想获得某年某月有多少天，请帮他编程实现。输入年份和月份，计算这一年这个月有多少天。
	//输入描述：
	//多组输入，一行有两个整数，分别表示年份和月份，用空格分隔。
	//输出描述：
	//针对每组输入，输出为一行，一个整数，表示这一年这个月有多少天。
	//示例1
	//输入：
	//2008 2
	//复制
	//输出：
	//29

	//int main()
	//{
	//    int y = 0;
	//    int m = 0;
	//    int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
	//    while (scanf("%d%d", &y, &m) != EOF)
	//    {
	//        int day = days[m - 1];
	//        if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
	//        {
	//            if (m == 2)
	//                day += 1;
	//        }
	//        printf("%d\n", day);
	//    }
	//    return 0;
	//void print_arr(int(*arr)[5], int row, int col)
	//{
	//
	//}
	//
	//int main()
	//{
	//
	//
	//    int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	//
	//    print_arr(arr, 3, 5);
	//
	//
	//    return 0;
	//}
	//void test(/*char** arr*/char* arr[])
	//{
	//
	//}
	//int main()
	//{
	//
	//    const char* arr[5] = { "hello", "bit" };
	//
	//    test(arr);
	//    return 0;
	//}

	// 9.17
	// 字符函数与字符串函数 
	//字符分类函数 需要包含头文件 ctype.h
	//int main()
	//{
	//    //int ret = islower('A');//0
	//    //int ret1 = islower('a');//2
	//    //int ret2 = islower('0');//0
	//    //printf("%d\n ", ret);
	//    //printf("%d\n ", ret1);
	//    //printf("%d\n ", ret2);
	//    //int ret3 = isxdigit('A');
	//    //printf("%d\n ", ret3);
	//    char arr[] = "I am a Student";
	//        int i = 0;
	//    while (arr[i] != '\0')
	//    {
	//        if (islower(arr[i]))//islower遇到小写字母时会返回非0的整数
	//        {
	//            arr[i] -= 32;//arr[i]=toupper(arr[i])
	//        }
	//
	//
	//        i++;
	//    }
	//    printf("%s\n ", arr);
	//    return 0;
	//}
	//字符转换函数 
	//int main()
	//{
	//    char ch = toupper('a');
	//    printf("%c ", ch);
	//    char ch1 = toupper('A');
	//    printf("%c ", ch1);
	//    return 0;
	//}
	//
	 //strlen 统计的是/0字符之前的个数 
	//int main()
	//{
	//
	//    //char arr[] = "abcdefg";
	//    //size_t len = strlen(arr);//7
	//    //char arr1[] = { 'a','b','v' };
	//
	//    //size_t len1 = strlen(arr1);//随机值
	//    if (strlen("abc" )- strlen("abcdef") > 0)
	//    {
	//        printf(">");//之前做过类似的 size_t 算出来的是无符号整数
	//        //-3 会进行整形提升 变成非常大的数 如果真的想进行比较可以强制类型转化为(int)
	//
	//    }
	//    else
	//    {
	//        printf("<");
	//    }
	//    return 0;
	////}
	//int main()
	//{
	//    printf("%u ", -3); //11111111111111111111111111111101
	//
	//    return 0;
	//}
	//strlen的模拟实现
	/*size_t mystrlen(const char* pa)
	{
		int count = 0;
		assert(pa != NULL);
		while (*pa)
		{
			pa++;
			count++;
		}
		return count;
	}

	int main()
	{
		char arr[] = "abcdefg";
		size_t len = mystrlen(arr);
		printf("%d ", len);

		return 0*/;
		//}
		 /*   size_t mystrlen(const char* pa)
			{
			   const char* start = pa;
			   assert(pa != NULL);
				while (*start)
				{
					start++;
				}
				return start - pa;
		}

			int main()
			{
				char arr[] = "abcdefg";
				size_t len = mystrlen(arr);

				printf("%d ", len);

				return 0;
			}*/

			//3.递归的方式 
			/* int mystrlen(char* pa)
			{
			if (*pa!=0)
			{
		return 1+mystrlen(pa + 1);



		}

		else
		{
		return 0;
		}
		}

		int main()
		{
		char arr[] = "abcdefg";
		size_t len = mystrlen(arr);
		printf("%d ", len);

		return 0;
		*/
		//}






		//int main()
		//{
		//    char arr1[] = "hello world";
		//    char arr2[10000];
		//    strcpy(arr2, arr1);
		//    printf("%s ", arr2);
		//    //将字符串拷过去的时候 /0也会拷贝过去 //头文件依旧是string.h
		//    //原字符串必须包含/0 没有/0无法结束
		//    //目标空间足够大 且可以修改 常量字符串就不可以
		//    return 0;
		//
		//}
		//模拟实现 strcpy
		// 
		// 
//strcpy函数返回的是目标空间的起始地址
//char *		
//const char* my_strcpy(char* dest,const char* src)
//{
//	int len = strlen(src);
//	 const char* pa = src;
//	assert(dest != NULL);
//	assert(src != NULL);
//	assert(src && dest);
//	/*for (int i = 0; i <= len; i++)
//	{
//		dest[i] = src[i];
//	}*/
//	/*while (*dest)
//	{
//		*dest = *src;
//		dest++;
//		src ++;
//	}
//	////*dest = *src;*//* 还可以更加简化 */
//	while (*dest++ = *src++)//后置加加 这么一个简单的代码 可以完成上述的操作 
//	{
//		;
//	}
//
//	return pa;
//}
//int main()
//{
//	char arr1[] = "abcdefg";
//	char arr2[200] = { 0 };
//	const char*pc= my_strcpy(arr2, arr1);
//	printf("%s ", pc);
//	return 0;
//}
//strcat  返回类型与上一个一样 返回的是目标空间的地址
//char* my_strcat(char* dest, const char* src)
//{//1.找目标的/0
//
//	char* ret =dest;
//	assert(dest && src);// \0 表示\ddd
//	// 0 数字0   '0' 数字字符0 ASCII值是48
//	//NULL也是0
//	while (dest)
//	{
//		dest++;
//	}
//	//2.拷贝过去
//	while (*dest++ = *src++)
//	{
//		;
//	}
//	return dest;
//}
//int main()
//{
//	char arr1[20000] = "abcdefg";
//	char arr2[] = "hijklmn";
//	//my_strcat(arr1, arr2);
//	/*strcat(arr1, arr1);*/// ?自己追加自己可以吗？
//	// /0会被覆盖 会陷入死循环 尽量不要自己追加自己
//	printf("%s\n", arr1);//空间开的要足够大目标字符串和原来的字符串也得有/0
//
//
//
//	return 0;
//}
//strcmp()是用来比较字符串的
//返回类型为int
//比较的不是字符串的长度 而是对应位置上的大小
//int my_strcmp(const char* p1, const char* p2)
//{
//	assert(p1 && p2);
//	while (*p1 == *p2)
//	{
//		if (*p1=='\0')
//		{
//			return 0;
//		}
//		p1++;
//		p2++;
//	}
//	return *p1 - *p2;//
//	/*if (*p1 > *p2)
//	{
//		return 1;
//	}
//	else
//	{
//		return -1;
//	}*/
//}
//int main()
//{
//	char arr1[] = "abcdefg";
//	char arr2[] = "abq";
//	char arr3[] = "abq";
//	int ret = my_strcmp(arr1, arr2);
//	//if(ret>0 )//这里不应该用=1 因为只有vs上返回的是1
//	printf("%d", ret);
//	return 0;
//	// vs -1 0 1
//}
//上面的长度不受限制的字符串函数
//strncpy 没有/0
//strncat 有/0
//strncmp 这是长度受限制的字符串函数
//int main()
//{
//	char arr1[] = "abcd";
//	char arr2[10000] = { 0 };
//	strncpy(arr2, arr1, 3);//当读取的长度不够时会自动用\0补齐
//	printf("%s ", arr2 );
//	// strncmp 比较前n个字符
//	return 0;
//
//}
//其余的其实同理 
//strstr函数 
//strtok函数
//192.169.110.123
//IP 地址 点分十进制的表示方式
//char *strtok(char *str,const char*sep)
//上面的. @都是分隔符
//sep参数指向一个字符穿 定义了用作分隔符的字符集合
//int main()
//{
//	char arr[] = "zpengwei@year.net*haha#int";
//	const char *sep = "@.*#";
//	char buf[256] = { 0 };
//	char* ret=NULL;
//	strcpy(buf, arr);
//	/*strtok(buf, sep);*/
//	for (ret = strtok(buf, sep); ret != NULL;ret=strtok(NULL,sep)) 
//	{
//		printf("%s\n", ret);
//	}
//	/*printf("%s\n", buf);
//	ret = strtok(NULL, sep);
//	printf("%s ", ret);
//	ret = strtok(NULL, sep);
//	printf("%s ", ret);*/
//	return 0;
//}
//strstr  char * (char *str1,char*str2)
//找到了返回第一次出现的起始地址 没找到返回null
//int main()
//{
//	char arr[] = { "cd" };
//	char arr1[] = "abcdecdfg";
//	char *ret=strstr(arr1, arr);
//	if (ret != NULL)
//	{
//		printf("%s ", ret);
//
//	}
//		
//
//	return 0;
//}
//const char* my_strstr(const char* p1,const char* p2)
//{
//	assert(p1 && p2);
//	const char* s1 = NULL;
//	const char* s2 = NULL;
//	const char* cur = p1;
//	//特殊情况 p2指向的是空字符串 直接返回p1
//	if (*p2 == '\0')
//	{
//		return p1;
//	}
//	while (*cur)
//	{
//		s1 = cur;
//		s2 = p2; 
//		while (*s1 && *s2 && * s1 == *s2)
//		{
//			s1++;
//			s2++;
//			
//	
//		}
//		if (*s2 == '\0')
//		{
//			return cur;
//		}
//
//		cur++;
//
//	}
//	return NULL;
//
//}
//int main()
//{
//	char arr[] = { "cda" };
//	char arr1[] = "abcdecdfg";
//	const char* ret = my_strstr(arr1, arr);
//		printf("%s ", ret);
//	return 0;
//}/strerror
// char *strerrot(int errnum);

//9.18 做作业 
//int int_cmp(const void * p1, const void * p2)
//{
//	return *(int *)p1 - *(int *)p2;
//}
//int main()
//{
//	
//	int arr[4];
//	for (int i = 0; i < 4; i++)
//	{
//		scanf("%d", &arr[i]);
//
//	}
//
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	qsort(arr, sz, sizeof(arr[0]), int_cmp);
//
//
//
//	for (int i = 0; i < 4; i++)
//	{
//		printf("%d", arr[i]);
//
//	}
//
//
//	return 0;
//}
//int main()
//{
//
//	float a, c;
//
//	char b;
//
//	scanf("%f%c%f", &a, &b, &c);
//	if (b == '+')
//	{
//		printf("%.2f", a + c);
//	}
//	else if (b == '-')
//	{
//		printf("%.2f",  a - c);
//
//	}
//	else if (b == '*')
//	{
//		printf("%.2f",  a * c);
//
//	}
//	else if (b == '/')
//	{
//		if (c == 0)
//		{
//			printf("error");
//		}
//		else
//		{
//			printf("%.2f", a / c);
//		}
//		
//	}
//	return 0;
//}
//int main()
//{
//	int arr[3];
//	for (int i = 0; i < 3; i++)
//	{
//		scanf("%d", &arr[i]);
//}
//	for (int j = 0; j < 3; j++)
//	{
//		if (arr[j] % 2 == 1)
//		{
//			printf("%d is odd number!\n",arr[j]);
//		}
//	}
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	int b = a;
//	if ((b / 10000 == b % 10))
//	{
//		b/= 10;
//		int ret = b % 10;
//		b /= 100;
//		int d = b % 10;
//		if (d == ret)
//		{
//			printf("%d是回文数", a);
//			goto end;
//		}
//		
//
//	}
//	printf("%d不是回文数", a);
//	end:
//	return 0;
//}
//int main()
//{
//	int a, b, c;
//	scanf("%d%d%d", &a, &b, &c);
//	if (a > b && a > c)
//	{
//		printf("%.2f", (float)a);
//	}
//	else if (b > a && b > c)
//	{
//		printf("%.2f", (float)b);
//
//	}
//	else
//	{
//		printf("%.2f", (float)c);
//
//	}
//	return 0;
//}
//int main()
//{
//	int score = 0;
//	scanf("%d", &score);
//	if (score >= 90)
//	{
//		printf("%d belongs to A.", score);
//	}
//	else if(score>60&&score<89)
//	{
//		printf("%d belongs to B.", score);
//	}
//	else
//	{
//		printf("%d belongs to C.", score);
//	}
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	if (a % 400 == 0 || (a % 4 == 0 && a % 100 != 0))
//	{
//		printf("%c", 'y');
//	}
//
//	else
//	{
//		printf("%c", 'n');
//
//	}
//
//	return 0;
//}
//
//int main()
//	
//{	int a,b,c; 
//	double p, m, n,x1,x2, x, y; 
//	
//	scanf("%d %d %d", &a, &b, &c);
//p = (b * b - 4 * a * c) * 1.0;
//if (a == 0 && b == 0)
//{
//	printf("Not an equation");
//}
//else if (a == 0 && b != 0)
//{
//	x1 = (c * 1.0 / b * 1.0)*(-1);
//	printf("%.2lf", x1);
//}
//else if (a != 0)
//{
//	if (p >= 0)
//	{
//
//		x1 = (-b + sqrt(p)) / (2 * a) * 1.0;
//		x2 = (-b - sqrt(p)) / (2 * a) * 1.0;
//		x = x1 > x2 ? x1 : x2;
//		y = x1 < x2 ? x1 : x2;
//		printf("%.2lf %.2lf", x, y);
//	}
//
//
//	else
//	{
//		m = (-b * 1.0) / (2 * a * 1.0);
//		n = sqrt(-p) * 1.0 / (2 * a * 1.0);
//		if (n < 0)
//			n = -n;
//		printf("%.2lf+%.2lfi %.2lf-%.2lfi", m, n, m, n);
//	}
//}
//return 0;
//}
//int main()
//{
//	int year, month, day = 0;
//	scanf("%d,%d,%d", &year, &month, &day);
//	int month1[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
//	if ((month1[month - 1] < day&&month!=2)||(month>12||month<1))
//	{
//		printf("data error.");
//	}
//	else
//	{
//		if (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0) && month > 3)
//		{
//			int sum = 0;
//			for (int i = 0; i < month - 1; i++)
//			{
//				sum += month1[i];
//			}
//			sum = sum + day + 1;
//			printf("It is the %d day.", sum);
//		}
//		else
//		{
//			int sum1 = 0;
//			for (int i = 0; i < month - 1; i++)
//			{
//				sum1 += month1[i];
//			}
//			sum1 += day;
//			printf("It is the %d day.", sum1);
//		}
//	}
//	return 0;
//}
//int main()
//{
//	int a = 100;
//	
//	for (a; a < 1000; a++)
//	{
//		int e = a;
//		int d = a;
//		int sum = 0;
//		int sum1 = 0;
//		while (d)
//		{
//		d = d/ 10;
//			sum++;
//		}
//
//		while (e)
//		{
//			
//			sum1 =sum1+pow(e%10,sum);
//			e = e / 10;
//
//		}
//		if (sum1 == a)
//		{
//			printf("%d\n", a);
//		}
//	}
//
//
//	return 0;
//}
//void find()
//{
//   
//    for (int i = 0; i <= 100000000; i++)
//    {
//        int add = 0;
//        int turn = i;
//        int change = i;
//        while (turn)
//        {
//            turn /= 10;
//            add++;
//
//        }
//        int sum = 0;
//        while (change)
//        {
//          
//            
//            sum = sum + pow(change % 10, add);
//            change /=10;
//            
//        }
//        if (sum == i)
//        {
//            printf("%d\n", i);
//
//        }
//
//    }
//}
//int main()
//
//{
//    find();
//    return 0;
//}
//char* my_strstr(char* p1, char* p2)
//{
//	char* s1 = NULL;
//	char* s2 = NULL;
//	
//	while (*p1)
//	{
//		s1 = p1;
//		s2 = p2;
//		while (*s1 && *s2 && *s1 == *s2)
//		{
//			s1++;
//			s2++;
//
//		}
//
//		if (*s2 == 0)
//		{
//			return p1;
//		}
//		p1++;
//	}
//	return NULL;
//}
//int main()
//{
//	char arr1[] = "abcddedcsddasadwa";
//	 char arr2[] = "abcdded";
//	char* ret = my_strstr(arr1, arr2);
//		printf("%s", ret);
//
//
//	return 0;
//}
//

// strerror 
//char *strerror(int errnum)
//errno全局变量 
//调用c语言的库函数 
//在errno中如果错误返回数字难以理解
//用strerror

//int main()
//{
//	int i = 0;
//	for (int i = 0; i <= 10; i++)
//	{
//		printf("%d%s\n",i, strerror(i));
//	}
//
//
//	return 0;
//}
//
//int main()
//{
//	FILE * pf=fopen("data.txt", "r");//r读 以读文件的形式打开文件，如果不存在就打开失败
//	if (pf == NULL)
//	{
//		printf("because %s\n", strerror(errno));
//		perror("because");
//	}//perror == printf+strerror
//	else
//	{
//		fclose(pf);
//		pf = NULL;
//	}
//	return 0;
//}
////	strerror // 将错误码对应的错误信息的字符串的起始地址返回
////   perror //将errno中错误的信息打印出来
////void perror (const char *str)

//// 先打印 str指向的字符串 打印：再打印空格，打印错误信息
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	for (int i = 0; i <= a; i++)
//	{
//		if (i*i % 391 == 13)
//		{
//			printf("%d ", i);
//		}
//
//	}
//
//	return 0;
//}
//int main()
//{
//	int aa = 0;
//	scanf("%d", &aa);
//	int sum = 1;
//	for (int i = 1; i <= aa; i++)
//	{
//		sum *= i;
//	}
//	printf("%d", sum);
//	return 0;
//}

//模拟实现strcpy
//char* my_strcpy(char* p1, char* p2)
//{
//	char* tmp = p1;
//	//int len = strlen(p2);
//	/*for (int i = 0; i <= len; i++)
//	{
//		p1[i] = p2[i];
//	}*/
//	while (*tmp++ = *p2++)
//	{
//		;
//	}//这里错误的原因是p1不再是目标的起始地址 
//	return p1;
//	
//	
//}
//模拟实现strstr
//char* my_strstr(char* p1, char* p2)
//{
//	char* s1 = NULL;
//	char* s2 = NULL;
//	
//	while (*p1)
//	{
//		s1 = p1;
//		s2 = p2;+
//		while (*s1 && *s2 && *s1 == *s2)
//		{
//			s1++;
//			s2++;
//		}
//		
//		if (*s2 == '\0')
//		{
//			return p1;
//		}
//		p1++;
//
//	}
//	return NULL;
//
//}
//int main()
//{
//	char arr[] = "abbcdbbefg";
//	char arr2[]="bbe";
//	char* ret=my_strstr(arr, arr2);
//	printf("%s ", ret);
//	
//	/*printf("%s",my_strcpy(arr2,arr)) ;*/
//
//}
//模拟实现strcat
//char* my_strcat(char* p1, char* p2)
//{
//	char* str = p1;
//	while (*str)
//	{
//		str++;
//	}
//	while (*str++ = *p2++)
//	{
//
//	}
//	return p1;
//}
//int main()
//{
//	char arr[100] = "abbcdbbefg";
//	char arr2[]="bbe";
//	char* ret=my_strcat(arr, arr2);
//	printf("%s ", ret);
//	
//
//
//模拟实现strcmp
//int my_strcmp(char* p1, char* p2)
//{
//	while (*p1 == *p2)
//	{
//		p1++;
//		p2++;
//	}
//	return *p1 - *p2;
//}
//int main()
//{
//	char arr[100] = "abbcdbbefg";
//	char arr2[]="abbcde";
//	int ret = my_strcmp(arr, arr2);
//	int ret1 = strcmp(arr, arr2);
//	printf("%d ", ret);
//	printf("%d ", ret1);
//
//	return 0;
//}
//模拟实现strncpy
//}
//char* strncpy(char* p1, char* p2, int a)
//{
//	char* str = p1;
//
//	while (a)
//	{
//		*str++ = *p2++;
//		a--;
//	}
//	return p1;
//}
//int main()
//{
//	char arr[100] = {0};
//	char arr2[]="abbcde";
//	
//	char* ret = strncpy(arr, arr2,2);
//
//	printf("%s ", ret);
//
//
//	return 0;
//}
//模拟实现strncat
//char* strncat(char* p1, char* p2, int a)
//{
//	char* str = p1;
//	while (*str)
//	{
//		str++;
//	}
//	while (a)
//	{
//		*str++ = *p2++;
//
//		a--;
//	}
//	return p1;
//}
//int main()
//{
//	char arr[1000] = {"abcd"};
//	char arr2[]="abbcde";
//	
//	char* ret = strncat(arr, arr2,2);
//
//	printf("%s ", ret);
//
//
//	return 0;
//}
//9.19
//C语言内存函数 
//针对内存块来处理的 面包块 一块面包i
// mem memmory 记忆 内存 
// memcpy 内存拷贝 strcpy strstr strtok strcmp strcat
// memmove 内存移动 
// memset 内存设置 
// memcmp  内存比较.
//void *my_memcpy(void* p1, void* p2, size_t a)
//{
//	void* p3 = p1;
//	assert(p1 && p2);

//for (int i = 0; i < a; i++)
//while(a)
//	{	
//		*(char*)p1 = *(char*)p2;//强制转化为char类型,因为int 4个字节过大
//		//(char *)p1++ 不行 因为强制转化是临时的,采用下面办法
//		p1 = (char*)p1 + 1;
//		p2 = (char*)p2 + 1;
//		a--;
//
//
//}
//return p3;
//}
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[20] = { 0 };
//	// 将arr1中的3 4  5 6 7拷贝放到arr2中
//	// memcpy 
//	// void *    (void *,       void *     ,  size_t num)
//	          //目标空间的地址 源空间的地址   被拷贝的字节个数
//	//返回目标空间的起始地址
//	my_memcpy(
// 单位是字节 与\0无关
//		int sz = sizeof(arr2) / sizeof(arr2[0]);
//
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr2[i]);
//
//	}
//
//	//memory函数不负责重叠内存的拷贝 
//	// 非要使用 结果是没定义的
//	return 0;
//}
//非要重叠 可以使用memmove 
//void * my_memmove(void* p1,const void* p2, size_t num)
//{
//	//从后面往前面拷贝更容易
//	//但是另一种拷贝方式会出问题
//	//可以分类讨论
//
//}
//int main()
//{
//
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//		int arr2[20] = { 0 };
//		/*memmove(arr1 + 2, arr1, 20);*/
//		my_memmove(arr1 + 2, arr1, 20);
//		//此时可以使用memmove
//
//}
//int main()
//{
//
//	printf("****\n ****\n  ****\n   ****");
//	/*
//	*****
//	   ***** 
//	    ***** 
//	     *****     */
//
//	
// return 0;
////}
////
//void * my_memmove(void* p1, void* p2,size_t num)
//{
//	void* p3 = p1;
//
//	///由分析可得 当p1<p2时 从前向后 else 从后向前 
//	if (p1 < p2)
//	{
//		while (num)
//		{
//			*(char*)p1 = *(char*)p2;
//			p1 = (char*)p1 + 1;
//			p2 = (char*)p2 + 1;
//
//			num--;
//		}
//		
//	}
//	else
//	{
//		while (num)
//		{
//
//			*((char*)p1 + num) = *((char*)p2 + num);
//			num--;
//		}
//
//	}
//
//	return p3;
//
//}
//int main()
//{
//
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//		int arr2[20] = { 0 };
//		/*memmove(arr1 + 2, arr1, 20);*/
//		my_memmove(arr1+2 , arr1, 20);
//		//此时可以使用memmove
//		for (int i = 0; i < 10; i++)
//		{
//			printf("%d ", arr1[i]);
//		}
//		return 0;
//}
//c语言标准规定memcpy实现不重叠的拷贝就行 
// 重叠的交给memmove
// 发现vs上的memcpy函数也能实现重叠的拷贝
//怕错误可以使用memmove 可以完全替代memcpy
//void *(void *,int ,size_t)
//memset 以字节设置内存 
//int main()
//{
//	char arr[] = "hello world";
//	memset(arr + 6, 'x', 5);
//	printf("%s ", arr);
//	int arr1[10] = { 0 };
//	memset(arr, 1, 4);//此时无法改变
//	//将每个字节都变为01
//	// 0 是00 00 00 00
//	// 变为了01 01 01 01
//
//
//
//
//	return 0;
//}
//memcmp
//int (const void *,const void *,size_t)
//int main()
//{
//	int arr1[] = {1,2,3,4,5};
//	//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
//	int arr2[] = { 1,2,3,5,6 };
//	//01 00 00 00 02 00 00 00 03 00 00 00 05 00 00 00 06 00 00 00
//	//int ret = memcmp(arr1, arr2, 12);//0
//	int ret1 = memcmp(arr1, arr2, 13);//-1
//	printf("%d ", ret1);//
//
//	return 0;
//}
// 数据在内存中的存储
//整数有原 反 补码 
//计算机中存放的是补码
//计算时用的是补码
//其实超过一个字节的数据在内存中存储的时候,
// 题目（Description）：

//计算 1 + 1 / 2 - 1 / 3 + 1 / 4 - 1 / 5 + 1 / 6 - …… + 1 / n。
//
//提示（Hint）：
//
//输出保留三位小数，使用printf("%.3f", ..) 格式。
//
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int i = 1;
//	double sum = 0;
//	for (; i <= n; i++)
//	{
//		int d = i;
//		if (i % 2 == 1 && i>1)
//		{
//			i = -i;
//		}
//		sum += (double)1 / i;
//		i = d;
//	}
//	printf("%.3f", sum);
//	return 0;
//}
//int fbnq(int a)
//{
//	int b = 1;
//	int c = 1;
//	int d = 0;
//	if (a < 3)
//	{
//		return 1;
//	}
//	else
//	{
//
//
//	while (a-2)
//	{
//		d = b + c;
//		b = c;
//		c = d;
//		a--;
//	}
//	}
//	return d;
//}
//int main()
//{
//	int n;
//	scanf("%d", &n);
//	int ret = fbnq(n);
//	printf("%d", ret);
//		
//
//	return 0;
//}
//有n个人坐在一起，问第n个人多少岁？
//
//（1）第n人说比第n - 1个人大2岁；
//
//（2）第n - 1个人说比第n - 2个人大 2 岁；
//
//（3）............
//
//（4）第3个人说比第 2 人大2岁；
//
//（5）第 2 个人说比第1个人大两岁；
//
//（6）第1个人说是自己 10 岁。
//
//请问第n个人多大岁数？
// 
//
//int main()
//{
//	int n=0;
//	scanf("%d", &n);
//	int d = 10;
//	while (n-1)
//	{
//		d += 2;
//		n--;
//
//	}
//	printf("%d ", d);
//
//	return 0;
//}\

//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = 0;
//	int ret1 = 0;
//	int ret2 = 0;
//	for (int i = 1; i <= n; i++)
//	{
//		if (i % 2 == 0)
//
//			ret += i;
//	}
//	for (int i = 1; i <= n; i++)
//	{
//		if (i % 2 == 1)
//
//			ret1 += i;
//
//	}
//	for (int i = 1; i <= n; i++)
//	{
//		
//			ret2 += i;
//	}
//	printf("%d\n", ret);
//	printf("%d\n", ret1);
//	printf("%d\n", ret2);
//
//	return 0;
//}
//int find_count(char* p1, char* p2)
//{
//	int len = strlen(p2);
//	int n = 0;
//
//	while (strstr(p1, p2) != NULL)
//	{
//
//		p1 =strstr(p1,p2)+ len;
//		n++;
//	}
//
//	return n;
//
//
//}
//int main()
//{
//	char arr1[1000];
//	char arr2[1000];
//	std::cin >> arr1 >> arr2;
//	int ret = find_count(arr1, arr2);
//	printf("%d ", ret);
//
//	
//
//
//	return 0;
//}
//int main()
//{
//	char arr1[] = "caucieecau123cau";
//	char arr2[] = "cauu";
//	char *ret = strstr(arr1, arr2);
//	printf("%s ", ret);
//
//	
//
//
//	return 0;
//}
//int main()
//{
//	float meter = 100;
//	int n = 0;
//	scanf("%d", &n);
//	float sum =100;
//
//	if (n < 0)
//	{
//		printf("error");
//	}
//	else
//	{
//		if (n == 1)
//		{
//			sum = meter;
//			meter /= 2;
//		}
//		else
//		{
//			while (n-1)
//			{
//				sum += meter;
//				meter /= 2;
//				n--;
//			}
//			meter /= 2;
//		}
//	}
//	printf("%.2f\n", sum);
//	printf("%.2f\n", meter);
//	return 0;
//}
//int search(int *list, int n, int x)
//{
//	for (int j = 0; j < n; j++)
//	{
//		if (list[j] == x)
//		{
//			return j;
//		}
//	}
//	return 0;
//	/*int j = n-1;
//	while (list[j] != x&&j>=0)
//	{
//		j--;
//	}
//	if (j == -1)
//	{
//		return 0;
//	}*/
//
//	/*return j;*/
//
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int list[1000];
//	for (int i = 0; i < n; i++)
//	{
//		scanf("%d", &list[i]);
//	}
//	int x = 0;
//	scanf("%d", &x);
//	int ret = search(list, n, x);
//	if (ret == 0 && list[ret] != x)
//	{
//		printf("Not found");
//		goto end;
//	}
//	printf("index=%d", ret);
//	
//	end:
//
//	return 0;
//}
//memcpy()

//void* my_memcpy(void* p1, void* p2, size_t num)
//{
//	void* p3 = p1;
//	while (num)
//	{
//		*(char *)p1 = *(char *)p2;
//		p1 = (char*)p1 + 1;
//		p2 = (char*)p2 + 1;
//
//		num--;
//	}
//
//	return p3;
//}
//void* my_memmove(void* p1, void* p2, size_t num)
//{
//	void* p3 = p1;
//	if (p1 < p2)
//	{
//		while (num)
//				{
//					*(char *)p1 = *(char *)p2;
//					p1 = (char*)p1 + 1;
//					p2 = (char*)p2 + 1;
//					num--;
//					
//				}
//	}
//	else
//	{
//		while (num--)
//		{
//			*((char*)p1 + num) = *((char*)p2 + num);
//			num--;
//		}
//
//	}
//	return p3;
//}
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//
//	memcpy(arr1 + 2, arr1, 20);
//	for (int i = 0; i < 10; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//
//	return 0;
//}
//void* my_memmove(void* dst, const void* src, size_t count)
//{
//	void* ret = dst;
//	if (dst <= src || (char*)dst >= ((char*)src + count))
//	{
//		while (count--)
//		{
//			*(char*)dst = *(char*)src;
//			dst = (char*)dst + 1;
//			src = (char*)src + 1;
//		}
//	}
//		else
//		{
//			
//			dst = (char*)dst + count - 1;
//			src = (char*)src + count - 1;
//			
//				while (count--) 
//				{
//					*(char*)dst = *(char*)src;
//					dst = (char*)dst - 1;
//					src = (char*)src - 1;
//				}
//		}
//	return(ret);
//}
//9.21 
//整形在内存中的存储
// 整形存储的是二进制的补码
//大端字节序存储
//小端字节序存储
//0x11 22 33 44
 // 存在内存中 可能11 22 33 44
//44 33 22 11
//将低字节放在高地址处,叫大端字节序存储
//将低字节放在低地址处,叫小端字节序 vs上放的是小端字节序
//大于1字节的数据使用 
//为什么要有大小端呢?
//在计算机系统中 每个地址单元对应一个字节
//一个字节为8个比特位,但是还有别的类型,short,long
///寄存器宽度大于一个字节
//那么必然存在着一个如何将多个字节安排的问题,因此就
// 存在着大端和小端字节序
// x86环境下是小端存储
// 不一定 有些处理器可以字节设置
// 
// 
//设计一个小的程序,判断机器大小端
//int main()
//{
//	int a = 1;
//	if (*(char*)&a == 1)
//	{///不能用(char)a
//		printf("小端");
//	}
////	else
////	{
////		printf("大端");
////	}
////	return 0;
////
////
////}
//int check_sys()
//{
//	int a = 1;
//	return *(char*)&a;
//}
//int main()
//{
//	if (check_sys() == 1)
//	{
//		printf("xiao");
//	}
//	else
//	{
//		printf("da");
//	}
//
//
//	return 0;
//}
//int main()
//{
//	char a = -1;
//	signed char b = -1;
//	unsigned char c = -1;
//	printf("a=%d,b=%d,c=%d", a, b, c);
//	// -1 -1 255 
//	//c语言中 char有无符号不确定
//	//但是大部分的编译器是有符号的
//	// 所以 a和b 输入-1
//	//-1 10000000000000000000000000000001
//	//   11111111111111111111111111111110
//	//   11111111111111111111111111111111
//	 //char一个字节8个比特位 11111111
//	//%d打印有符号的整数
//	//%u打印无符号的整数
//	return 0;


//}
//int main()
//{
//	char a = -128;
//	printf("%u\n", a);
//	//4294967168
//	//10000000000000000000000010000000
//	//11111111111111111111111101111111
//	//11111111111111111111111110000000
//	//11111111111111111111111110000000
//	
//	return 0;
//}
//int main()
//{
//	char a = 128;
//	printf("%u\n", a);
//	return 0;
//	//00000000000000000000000010000000
//	//00000000000000000000000010000000
//	//00000000000000000000000010000000
//	//10000000 //与上面的一样
//
//
//}
//int main()
//{
//	char a = 256;
//	printf("%u", a);
//	//0 截断了 vs上也会报警告
//
//	return 0;
//}
// char类型的取值范围
//  -128~127
// 八个比特位
//10000000 不是-0 
//取反 +1 11111111+1=100000000 越界了
//直接翻译成128
//128 110000000
//    101111111
//    110000000
//    101111111
///   110000000
//    101111111
//    110000000
//    110000000
//int main()
//{
//
//	signed int num = -10;
//	// 用unsigned int打印数据相同
//	// 因为内存中数据放的都是-10，如何看待由%u或者%d来决定
//
//	printf("%d", num);
//	printf("%u", num);
//
//	return 0;
//}
//int main()
//{
//	char a[1000];
//	int i;
//	for (i = 0; i < 1000; i++)
//	{
//		a[i] = -1 - i;//-1
//	}
//	printf("%d", strlen(a));
//	
//	// strlen(&arr[0])
//	//strlen 求得是字符串的长度
//	//统计的是\0之前出现的字符个数
//	//?为什么 
//	// char类型的范围是-128`127
//	// a[0]=-1 一直存放 -1 -2 -3 ...-128
//	// 下一个就是127 ......0
//	// 一共的长度是 127+128=255
//
//
//	return 0;
//}
//int main()
//{
//	char a[] = { '2','1','\0','3'};//2 1 0 3 \0
//	char a1[] = { "21105" };
//	printf("%d", *(a1+1));//字符2的ASCII值就是50
//
//	int ter = strlen(a1);
//	//printf("%d", ter);//与上一个区别就在 上一个放进去的是int类型的数字
// // 会认为就是数字 所以遇到0才会停止计算 
// //参考下一个为例 
// // 而这个本身放进去的是char类型的值 数字会有对应的ASCII值 所以放2106 \0 会算出4
// // '2''1''0'返回随机值
//
//	return 0;
//}
//int main()
//{
//	int a = 5;
//	char arr[5];
//	for (int i = 0; i < a; i++)
//	{
//		arr[i] = 3 - i;
//
//	}
//	int len = strlen(arr);
//	printf("%d", len);
//	return 0;
//}
////unsigned char i = 0;
////
////int main()
////{
//////	unsigned char 的取值范围是0~255 超不过这个范围 ,所以会死循环
//////	for (i = 0; i <= 255; i++)
////	{
////		printf("%d\n",i);
////		Sleep(100);
////	}
////
////	return 0;
////}
//int main()
//{
//	unsigned int i;
//	// unsigned 恒大于0 所以仍然会死循环
//	for (i = 9; i >= 0; i--)
//	{
//		printf("%u\n", i);
//		sleep(100);
//
//	}
//
//	return 0;
//}
//int main()
//{
//	int a[4] = { 1,2,3,4 };
//	int* ptr1 = (int*)(&a + 1);
//	int* ptr2 = (int*)((int)a + 1);
//	printf("%x,%x", ptr1[-1], *ptr2);
//	// 4 2000000 
//	// // ?第一个好理解 
//	// // 对于第二个 
//	// //  a强制转化为int类型 加1 再转化为(int *)比如说0x10 转化为int是16 +1=17
//	// 再转化为int *是0x11  跳过一个字节 a 小端字节序 01 00 00 00 02 00 00 0....
//	// //             上方操作由分析                   .跳过一个字节 到00 *访问四个字节
//	// // 00 00 00 02  小端字节序 0x02 00 00 00 打印0 0x没意义 所以是2 00 00 00
//	// // 
//	// *(ptr1-1)
//	//%x是16进制打印
//
//
//	return 0;
//}
//int main()
//{
//	signed int a = -1;
//	unsigned int a1 = -1;
//	printf("%d\n", a);
//	printf("%u\n", a);
//
//	printf("%d\n", a1);
//	printf("%u\n", a1);
//	return 0;
//}
// 浮点数在内存中的存储
// 
//int main()
//{
//	int n = 9;
//	float* pfloat = (float*)&n;
//	printf("n的值为:%d\n", n);//9
//	printf("*pfloat的值为:%f\n", *pfloat);//0.00000000
//	*pfloat = 9.0;
////n的值为:9
////* pfloat的值为 : 0.000000
////n的值为 : 1091567616
////* pfloat的值为 : 9.000000
//
//	printf("n的值为:%d\n", n);
//	printf("*pfloat的值为:%f\n", *pfloat);
//	return 0;
//}
// 整数和浮点数 在内存中的存储方式有区别
//
//十进制5.5 
//化为2进制 101.1
//          1.011*2^2
//         (-1)^0*1.011*2^2
// 浮点数的存储 存储的就是S M E这样的值
//32 个比特位

//1个符号 s 8个存E 23个存放M
// 64个比特位
// 1   11  52  S M E
//int main()
//{
//	float f = 5.5f;
//	//S=0;
//	//E=2
//	//M=1.011
//	return 0;
//}
//int main()
//{
//	int n = 9;
//	// 00000000000000000000000000001001
//	float* pfloat = (float*)&n;
//	//放在float类型中 E=0 由规定趋近于0
//	printf("n的值为:%d\n", n);//9
//	printf("*pfloat的值为:%f\n", *pfloat);//0.000000
//
//	*pfloat = 9.0;
////n的值为:9
////* pfloat的值为 : 0.000000
////n的值为 : 1091567616
////* pfloat的值为 : 9.000000
//	//01000001000000000000000000000000
//	printf("n的值为:%d\n", n);
//	printf("*pfloat的值为:%f\n", *pfloat);
//	return 0;
//}
//int main()
//{
//	char arr1[5], arr2[] = "welcome";
//	// / / / / / w e l c o m e\0
//	//w  e l c o m e \0
//	strcpy(arr1, arr2);
//	printf("%s", arr1);
//	printf("%s", arr2);
//
//	return 0;
//}
// 
//浮点数在内存中的存储,不需要死记硬背,
//有一电文，已按下面规律译成密文。
//
//A->Z a->z
//
//B->Y b->y
//
//C->X c->x
//
//… …
//
//即第一个字母变成第26个字母，第i个字母变成第（26 - i + 1）个字母，非字母字符不变。要求编程输入一串密文，将密文译回原文并打印输出。
//
//输入（Input）：
//
//一串密文。
//
//输出（Output）：
//
//将密文译回的原文。
//
//提示（Hint）：
//
//A - Z的ASCII码分别为65 - 90，a - z的ASCII码分别为97 - 122。

//void change(char arr[])
//{
//	size_t len = strlen(arr);
//	for (int i = 0; i < len; i++)
//	{
//		if (arr[i] >= 65 && arr[i] <= 90 )
//		{
//			arr[i] = arr[i] + 25 - (arr[i] - 65) * 2;
//
//
//		}
//
//		else if(arr[i] >= 97 && arr[i] <= 122)
//		{
//			arr[i] = arr[i] + 25 - (arr[i] - 97) * 2;
//
//		}
//		else
//		{
//
//
//		}
//	}
//
//}
//
//int main()
//{
//	char arr[1000];
//	std::cin >> arr;//gets(arr)//vs c++文件中不可用  但是devc++可以
//	change(arr);
//	std::cout << arr;
//	return 0;
//}


//示例（Sample）：
//
//输入（Input）：
//
//hello, world!
//
//输出（Output）：
//
//svool, dliow!
// //10个小孩围成一圈分糖果。老师首先给每个小孩若干块糖果（每个小孩得到的糖果块数都不相等），然后命令所有的小孩同时将自己手中的糖果分一半给右边的小孩（第二个小孩给第一个小孩，以此类推，第十个小孩给第九个小孩，第一个小孩给第十个小孩）；糖果块数为奇数的人可向老师要一块。问：经过这样几次调整后大家手中的糖果的块数都一样？最后每人各有多少块糖果？
//
//输入（Input）：
//
//老师分给10个小孩的初始糖果块数（整数）。
//
//输出（Output）：
//
//（1）第一行是调整的次数；
//
//（2）第二行是最后每人拥有的糖果块数。
//
//示例（Sample）：
//
//输入（Input）：
//
//10 2 8 22 16 4 10 6 14 20
//
//输出（Output）：
//
//17
//
//18
//while()
//{
// int a=0;
// if(arr[a]=arr[a+1];
// a++;else{break;}

//
//void find_time(int arr[])
//{
//	int sum = 0;
//	int a = 0;//次数
//	while (a < 9)
//	{
//		
//		if (arr[a] == arr[a + 1])
//		{
//			a++;//判断是否完成结束条件 
//		}
//		else
//		{
//			a = 0;
//			for (int c = 0; c < 10; c++)
//			{
//				if (arr[c] % 2 == 1)
//				{
//					arr[c]++;//将所有的糖果变成偶数
//				}
//			}
//			int  tmp[10];
//			for (int d = 0; d < 10; d++)
//			{
//				tmp[d] = arr[d] / 2;
//			}
//			for (int j=0;j<10;j++)
//			{
//				
//				if (j == 9)
//				{
//					arr[9] += -tmp[9] + tmp[0];
//				}
//				else//完成传递
//				{
//					arr[j] += -tmp[j] + tmp[j + 1];//传递糖果之后 自己的糖果少了一半，先定义一个tmp，存储一半的数目，再使用
//					
//				}
//			
//
//			}
//			sum++;
//		}
//	}
//	
//	
//	
//	printf("%d\n", sum);
//	printf("%d", arr[1]);
//}
//int main()
//{
//	int arr[10];
//	for (int i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//    }
//	find_time(arr);
//
//
//	return 0;
//}

// 检查所有人是否有相同的糖果数量
//int all_equal(int arr[])
//{
//	for (int i = 1; i < 10; i++) {
//		if (arr[i] != arr[0]) {
//			return 0;  // 不相同，返回0
//		}
//	}
//	return 1;  // 相同，返回1
//}
//
//void find_time(int arr[]) {
//	int sum = 0;  // 传递次数
//
//	// 主循环，直到所有人的糖果数量相同
//	while (!all_equal(arr)) {
//		// 将奇数的糖果变为偶数
//		for (int i = 0; i < 10; i++)
//		{
//			if (arr[i] % 2 == 1)
//			{
//				arr[i]++;  // 如果是奇数，先加1变为偶数
//			}
//		}
//
//		// 保存当前要传递的一半糖果
//		int temp[10];
//		for (int i = 0; i < 10; i++)
//		{
//			temp[i] = arr[i] / 2;
//		}
//
//		// 进行传递
//		for (int i = 0; i < 10; i++) 
//		{
//			if (i == 9)
//			{
//				arr[9] = arr[9] - temp[9] + temp[0];  // 最后一人传递给第一个人
//			}
//			else {
//				arr[i] = arr[i] - temp[i] + temp[i + 1];  // 传递糖果给下一个人
//			}
//		}
//
//		sum++;  // 每次传递后次数+1
//	}
//
//	printf("传递次数: %d\n", sum);
//	printf("最终每个人的糖果数量: %d\n", arr[0]);  // 所有人糖果数量相同
//}
//
//int main() {
//	int arr[10];
//	printf("请输入10个人的糖果数量：\n");
//	for (int i = 0; i < 10; i++) {
//		scanf("%d", &arr[i]);
//	}
//
//	find_time(arr);
//
//	return 0;
//}
// 
//对于一个自然数，如果其各位数字之和为8，则成为一个8和数；如果是相邻两个自然数都是8和数，则称为一个8和数对，比如79和80。编写程序找到前n项的8和数对，输出的8和数对用空格分隔，小数在前，大数在后，并且每行输出一对。
//
//输入（Input）：
//
//n
//
//输出（Output）：
//
//8和数对用（空格分隔）
//
//输出说明：小数在前，大数在后，并且每行输出一对。
//
//示例（Sample）：
//
//输入（Input）：
//
//5
//
//输出（Output）：
//
//79 80
//
//169 170
//
//259 260
//
//349 350
//
//439 44
// 


//9.21_结构体
//自定义的类型,
//struct 
//结构的每个成员可以是类型不同的变量
//struct tag
//{
//	menber_list
//}variable 
//struct book
//{
//	char name[20];
//	char author[20];
//	float price;
//    char id[19];
//
//
//}b4,b5,b6;
//int main()
//{
//	struct book b1 = { "penggec","pengge",38.8f,"PG123" };
//	struct book b2;
//	struct book b3;
//	return 0;
//}//浮点数在内存中有可能是不能精确保存的
////浮点数比较不用等号
////float f=3.45;
////if(abs(f-3.45)<0.00000001)
//// 相等
//// abs 绝对值
//结构体的特殊声明
//匿名的特殊声明 只能直接创建变量
//struct
//{
//	char c;
//	int i;
//	double d;
//}s1,s2;
//struct
//{
//	char c;
//	int i;
//	double d;
//}*ps;
//int main()
//{
//	ps = &s1;
//	//这种方式不允许
//	//只能这个类型一次时可以用匿名
//
//
//	return 0;
//}
//结构的自引用

//数据结构
// 1 2 3  4 5 
//  在内存中连续的存放 顺序表
//  瞎放  1能找到2 类推
// 链表   结点 
//typedef struct node
//{
//	int data;//存放数据 //数据域
//	//struct node next;
//	//这样做不行 结构体的大小无穷了 
//	struct node* p1;//指针域
//	node* p1;//也不行 先定义结构体叫node然后才能引用 
//
//}node;
//int main()
//{
//
//
//
//	return 0;
//}
//结构体大小？
//结构体对齐 很重要
//struct s1 {
//	char c1;
//	char c2;
//	int n;
//};
//struct s2 {
//	char c1;
//	int n;
//	char c2;
//};
//int main()
//{
//	printf("%zd\n", sizeof(struct s1));//8
//	printf("%zd\n", sizeof(struct s2));//12
//	//涉及了结构体的对齐
//	//结构体的成员在内存中存在对齐现象
//	struct s1 s1 = { 0 };
//	// offsetof 宏
//	//计算结构体成员相较于结构体变量起始位置的偏移量
//	int ret = offsetof(struct s1, c1);
//	int ret2 = offsetof(struct s1, c2);
//	int ret3 = offsetof(struct s1, n);
//	int ret4 = offsetof(struct s2, c1);
//	int ret5 = offsetof(struct s2, n);
//	int ret6 = offsetof(struct s2, c2);
//	//printf("%zd", ret);//0
//	//printf("%zd", ret2);//1
//	//printf("%zd", ret3);//4
//	printf("%zd", ret4);//0
//	printf("%zd", ret5);//4
//	printf("%zd", ret6);//8
//	return 0;
//
//}
// 对齐规则 ？
// 1.结构体第一个成员对齐到起始位置偏移量为0的地址处
// 2.其他成员变量要对齐到某个数字的整数倍数的地址处
//对齐数 编译器默认的对齐数与该成员变量自身的大小
//vs默认为8
//Linux中qcc没有默认对齐数
//3.总大小为最大对齐数的整数倍
//4.如果嵌套了结构体成员，嵌套的结构体成员对齐到自己的成员的最大对齐数
// 的整数倍处，结构体的整体大小就是所有最大对齐数的整数倍
// 
//
//
//struct s1 {
//	char c1;
//	char c2;
//	int i;
//};
//struct s3
//{
//	double d;
//	char c;
//	int i;
//};
//struct s4
//{
//	char c1;
//	struct s3 s3;
//	double d;
//};
//int main()
//{
//	struct s1 s1;
//	printf("%zd", sizeof(struct s4));
//	return 0;
//}
// ？为什么要存在对齐呢
//1.平台原因 
//不是所有的硬件都能访问任意地址上的任意数据的
//2性能原因 
//数据结构应该尽可能在自然边界上对齐
//访问未对其的内存，处理器需要做两次访问
//而对齐的内存只需要一次访问
//
// 总的来说，结构体的内存对齐是拿空间换时间的做法
// #pragma pack(1)
//#pragma pack(1)//修改默认对齐数，一般是2的次方数
//struct s1
//{
//	char c1;
//	int n;
//	char c2;
//
//};
//#pragma pack()//
//int main()
//{
//
////可以修改默认对齐数
//	
//
//	return 0;
//}
//struct S
//{
//	int arr[1000];
//	int n;
//	char ch;
//
//};
//void print2(struct S* ps)
//{
//	int i = 0;
//	for (; i < 10; i++)
//	{
//		printf("%d\n", ps->arr[i]);
//	}
//	printf("%d", ps->n);
//}
//void print1(struct S tmp)
//{
//	int i = 0;
//	for (; i < 10; i++)
//	{
//		printf("%d\n", tmp.arr[i]);
//
//	}
//}
//
//int main()
//{
//	struct S s1 = { {12,3,4,5,6},10,'w' };
//	print1(s1);//传值调用
//	print2(&s1);//传址调用
//	// 两种哪个更好呢？
//	// 结构体传参的时候，要传递地址
//	//不想被修改就加上const
//	
//
//	return 0;
//}
//  位段
//结构体实现位段
//位段和结构体相关
//什么是位段？
//1.位段的成员必须是int unsigned int ,C99中也可以选择其他类型 
//2.位段的成员名后边有一个冒号和数字
//struct s
//{
//	int _a:2;
//	//位段中的位是指二进制的位
//	//数字有限制不能超过最大比特位
//	int _b:5;
//	int _c:10;
//	int _d:30;
//};
//int main()
//{
//	printf("%zd\n", sizeof(struct s));
//	//位段节省空间
//	return 0;
//}
//struct S
//{
//	char a : 3;
//	//给定了空间后，在空间内部是从左向右还是i从右向左
//	//这个不确定
//	//当剩下的空间不足以存放下一个空间的时候，空间是浪费还是i使用，不确定
//
//
//	char b : 4;
//	char c : 5;
//	char d : 4;
//
//};
//int main()
//{
//	
//	struct S s = {0};
//	s.a = 10;
//	s.b = 12;
//	s.c = 3;
//	s.d = 4;
//	printf("%zd", sizeof(struct S));//3)
//
//	return 0;
//	//和结构相比 位段可以省空间，但是会有跨空间的危险
////不能位段的成员不能&
//}
//struct s
//{
//	int a : 2;
//	int b : 5;
//	int c : 10;
//	int d : 30;
//};
//int main()
//{
//	struct s s1 = { 0 };
//	//scanf("%d", &s1.a);//不允许采用位域的地址
//	int d = 0;
//	scanf("%d", &d);
//	s1.a = d;//可以采用这种赋值方式
//
//
//	return 0;
//}
//枚举 
//一一列举
//声明枚举类型
//enum //英语意思是枚举
//#define male 2
////可以使用define 为什么要用enum？
////增加代码的可读性
////严谨
////便于调试 ，预处理阶段会删除#define定义的符号
////使用方便
////
//enum sex
//{
//	MALE=2,
//	FEMALE,
//	SECERT
//};
//int main()
//{
//	//MALE = 8;不可以修改
//	enum sex sex1 = MALE;
//	
//	printf("%d\n", MALE);
//	printf("%d\n", FEMALE);
//	printf("%d\n", SECERT);
//
//
//
//	return 0;
//}
//写一个计算器 +-*/\

//enum option
//{
//	exit,
//	add,
//	sub,
//	mul,
//	div
//
//};
//void menu()
//{
//	printf("0.exit 1.add 2. 3. 4.");
//}
//int main()
//{
//	int input = 0;
//	do
//	{
//		menu();
//scanf("%d", &input);
//switch (input)
//{
//case add:
//	break;
//case sub:
//	break;
//case mul:
//	break;
//case div:
//	break;
//case exit://看到名称可以想到干什么
//
//	break;
//default:
//		break;
//
//}
//
//	} while (input);
//	return 0;
//}
//联合体 关键字 union
//结构体 关键字  struct
//枚举   关键字  enum
//union Un//联合体只为最大的成员分配空间
//
//{
//	char c;
//	int i;
//	
//
//};
//struct s
//{
//	char c;
//	int i;
//};
//int main()
//{
//	printf("%zd", sizeof(struct s));//8
//	printf("%zd", sizeof(union Un));//4
//
//
//	return 0;
//}
//union Un
//{
//	char c;
//	int i;
//
//};
//int main()
//{
//	union Un un = { 0 };
//	printf("%p\n", &un);
//	printf("%p\n", &(un.c));
//	printf("%p\n", &(un.i));
//	//地址一模一样
//	//i和c公用同一块内存空间
//	//也叫共用体 
//	//联合体大小至少是最大成员的大小
//	//“至少”
//	un.i = 0x11223344;
//	un.c = 0x55;
//	return 0;
//}
//union un
//{
//	char arr[5];
//	int i;//8
//
//};
//union un
//{
//	short arr[7];
//	int i;//16 也存在对齐现象
//
//
//};
//int main()
//{
//	printf("%zd", sizeof(un));
//
//
//	return 0;
//}
//联合的一个联系 判断当前机器是大端还是小端
//union un
//{
//	char c;
//	int i;
//}un1;
//
//int main()
//{
//	un1.i = 1;
//	printf("%x", un1.c);
//	int a = 1;
//	int* c = &a;
//	printf("%x", *(char*)c);
//
//}
//struct stu
//{
//	int num;
//	char name[10];
//	int age;
//};
//
//void fun(struct stu* p)
//{
//	printf("%s\n", (*p).name);
//	return;
//}
//
//int main()
//{
//	struct stu students[3] = { {9801,"zhang",20},
//							 {9802,"wang",19},
//					{9803,"zhao",18} };
//	fun(students + 1);
//	return 0;
//}// wang
//有一个n面的骰子，每一面分别为1~n，不断投掷骰子，直到骰子上的数累加超过50停止，问这累加和的平均值是多少（数学期望）
//
//输入一个整数，即骰子的面数
//
//输出一个小数，保留1位小数， 按题意的这累加和的平均值是多少
//
//样例输入
//
//10
//
//样例输出
//
//54.0
//
//样例输入
//
//6
//
//样例输出
//
//52.7
//从数字1、2.....20中随机抽取5个数字（允许重复），则其其数字之和等于n的概率为______．
//
//输入整数
//
//输出一个小数（保留2位小数）
//
//样例入
//
//63
//
//样例输出
//
//0.02
//
//保留两位小数的方法，输出格式print  "%.2f" % 概率值
//int main()
//{
//	srand((unsigned int)time(NULL));
//	int a = 0;
//	int f = 5;
//	scanf("%d", &a);
//	int sum = 0;
//	int sum1 = 0;
//	int arr[5];
//	
//	again:
//		int d = rand() % 19 + 1;
//		while (f)
//		{
//			for (int h = 0; h < 5; h++)
//			{
//				arr[h] = d;
//			}
//			sum += d;
//			f--;
//
//		}
//		if (sum == a)
//		{
//			sum1++;
//		}
//		goto again;
//		float a = (float)sum1 / (20 * 20 * 20 * 20 * 20);
//		printf("%.2f", a);
//	return 0;
//}
//
//从数字1、2、3、4、5中随机抽取3次数字（不允许重复）组成一个三位数，则其各位数字之和等于n的概率为______．
//
//输入整数
//
//输出一个小数（保留2位小数）
//
//样例入
//
//9
//
//样例输出
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	int arr[5] = { 1,2,3,4,5 };
//	int sum=0;
//	for (int i = 0; i < 5; i++)
//	{
//		
//		for (int d = 0; d < i; d++)
//		{
//			
//			for (int f = 0; f < d; f++)
//			{
//		
//
//				if (arr[i] + arr[d] + arr[f]==a&&i!=d&&d!=f)
//				{
//					sum++;
//				}
//			}
//		}
//	}
//	
//	float f = (float)sum / 10;
//	printf("%.2f", f);
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	int sum = 0;
//	int arr[20] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 };
//	for (int j = 0; j < 20; j++)
//	{
//		for (int g = 0; g < 20; g++)
//		{
//			for (int h = 0; h < 20; h++)
//			{
//
//				for (int x = 0; x < 20; x++)
//				{
//					for (int i = 0; i < 20; i++)
//					{
//						if (arr[j] + arr[g] + arr[h] + arr[x] + arr[i] == a)
//						{
//							sum++;
//						}
//					}
//				}
//			}
//		}
//	}
//
//
//	float f = (float)sum / (20 * 20 * 20 * 20 * 20);
//	printf("%.2f", f);
//	return 0;
//}
//int fbnq(int a)
//{
//	if (a <= 3)
//	{
//		return 1;
//	}
//	else
//	{
//		return fbnq(a - 1) + fbnq(a - 2) + fbnq(a - 3);
//	}
//}
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	int ret=fbnq(a);
//	printf("%d", ret);
//	return 0;


//double average_sum(int n)
//{
//	int simulations = 100000; // 设置模拟次数
//	double total_sum = 0.0;
//
//	for (int j = 0; j < simulations; j++) 
//	{
//		int sum = 0;
//		while (sum <= 50) 
//		{
//			sum += (rand() % n) + 1; // 生成 1 到 n 的随机数
//		}
//		total_sum += sum; // 累加超过 50 的和
//	}
//
//	return total_sum / simulations; // 计算平均值
//}
//
//int main()
//{
//	int n;
//	srand((unsigned int)time(NULL)); // 设置随机种子
//	printf("请输入骰子的面数: ");
//	scanf("%d", &n);
//
//	double result = average_sum(n);
//	printf("累加和的平均值: %.1f\n", result);
//
//	return 0;
//}
//解决高中的古典概率问题：
//有a、b两个袋子，a袋中装有4个白球、2个黑球，
//b袋中装有3个白球、4个黑球，
//从a、b两个袋子中各取n个球交换之后，
//求a袋中有4个白球的概率。
//
//
//输入
//
//一个整数n
//
//输出：
//
//一个小数，保留2位小数，求a袋中有4个白球的概率。
//
//样例输入：
//
//2
//
//样例输出：
//
//0.38
//
//样例输入：
//
//4
//
//样例输出：
//
//0.27
//void exchange(int a[], int b[])
//{
//	int d = 0;
//	srand((unsigned int) time(NULL));
//	scanf("%d", &d);
//	int v = 0;
//	int sum = 0;
//	int sum1 = 0;
//	int tmp3 = 0;
//	int tmp4 = 0;
//	int count = 0;
//	int m = 100000;
//	// 1 2 2
//	while (m)
//	{
//		if (d == 0)
//		{
//			sum++;
//			sum1++;
//		}
//		int tmp1[6];
//		int tmp2[7];
//		memcpy(tmp1, a, 24);
//		memcpy(tmp2, b, 28);
//		int a1 = rand() % 6;
//		int b1 = rand() % 7;
//
//		//?怎么写交换呢？
//		for (int q = 0; q < 6; q++)
//		{
//
//		}
//		sum++;
//		for (v = 0; v < 6; v++)
//		{
//			count += tmp1[v];
//
//		}
//		if (count == 4)
//		{
//			sum1++;
//		}
//		m--;
//	}
//	double d1 = (double)sum1 / sum;
//	printf("%.2lf",d1 );
//}
//int main()
//{
//	int a[7] = { 1,1,1,1,0,0 };//1 white  0 black
//	int b[7] = { 1,1,1,0,0,0,0 };
//
//	exchange(a, b);
//
//	return 0;
//}
//动态内存申请 9.24
//int main()
//{
//	int n = 0;
//	int arr[10] = { 0 };
//	//空间大小时固定的，不可以调整
//	//所以引入动态内存开辟
//
//	return 0;
//}
//malloc 
//void *malloc(size_t size)
//开辟内存块 自己设定的 大小是字节
//参数单位是字节

//申请空间成功，返回首地址
//失败，返回空指针
//int main()
//{
//	//申请十个整形的空间
//	int * p = (int*)malloc(10 * sizeof(int));
//	if (p == NULL)
//	{
//		//空间开辟失败
//		perror("malloc");//原因
//		return 1;
//	}
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		p[i] = i + 1;
//	}
//	//和数组有什么u区别呢?
//	// 1.大小可以调整
//	// 2.存放的位置不同
//	//局部变量   栈区
//	// 形式参数   
//	// 
//	//
//	// 动态内存
//	// malloc    堆区
//	// free
//	//calloc
//	// realloc
//	// 
//	// 
//	// 
//	// 
//	// 
//	// 
//	// 全局变量
//	// static修饰的静态变量  静态区
//	// //
//	//如果size为0,malloc的行为是标准没定义的
//	//取决于编译器
//
//
//	return 0;
//}
//int main()
//{
//	malloc(INT_MAX);
//	perror("malloc");// not enough space
//
//	//释放空间 free
//	//void free(void *)
//	
//	return 0;
//}
//int main()
//{
//	int* p = (int*)malloc(40);
//	free(p);
//	//p指向的空间不属于当前程序，但是还是
//	//找到能这个空间
//	p = NULL;  //free 通过代码的方式去释放内存
//	//不释放的话，程序结束的时候也会被i自动回收
//
//	return 0;
//}
//int main()
//{
//	int arr[10] = { 0 };
//	int* p = arr;
//	free(p);//error
//	p = NULL;
//
//
//	return 0;
//}
//int main()
//{
//	int* p = NULL;
//	free(p);
//	//无影响
//	//malloc 和free 最好成对使用
//
//
//	return 0;
//}
//calloc 
// void *(calloc)(size_t num,size_t size)
//int main()
//{
//	//申请10个整形的空间
//	//malloc (10*sizeof(int ));
//	int *p=(int*)calloc(10, sizeof(int));
//	for (int i = 0; i < 10; i++)
//	{
//		printf("%d", p[i]);//0 0 0 0 0 0 0 0 0 0 0
//}//calloc 初始化为0
//	// malloc 只进行初始化
//	return 0;
//}
//realloc 
//void *realloc (void *ptr,size_t size);
//realloc 可以调整
//int main()
//{
//	int* p = (int*)calloc(10, sizeof(int));
//	//变成了20个整型空间
//	int *ptr=(int *)realloc(p, 20 * sizeof(int));
//	//最好不拿p
//	if (ptr!=NULL)
//	{
//		p = ptr;
//	}
//	//realloc 在调整空间的时候有两种情况，
//	//空间后面的空间不一定扩容
//	//够了 ，就直接扩容 返回p
//	//不够了，会在内存中再去找一个空间，
//	//直接开辟扩容后的大小（在堆区）
//	//然后将旧的数据拷贝到新的空间
//	//会释放旧的空间
//	//返回新的地址
//
//
//
//	return 0;
//}
//常见错误
//int main()
//{
//	int *p=(int *)malloc(10 * sizeof(int));
//	if (p == NULL)
//	{
//		perror("malloc");
//		return 1;
//	}
//	int i = 0;
//	for (; i < 10; i++)
//	{
//		p[i] = i;
//	}
//	free(p);
//	p = NULL;
//	return 0;
//}
//对动态内存空间进行越界访问
//malloc(40) for(int i;i<40;i++)

//int main()
//{
//	int a = 10;
//	int* p = &a;
//	free(p);//free只能free掉动态内存，不能对其他的使用
//
//	p = NULL;
//
//	return 0;
//}
//int main()
//{
//	int* p = (int*)malloc(40);
//
//	for (int i = 0; i < 10; i++)
//	{
//		*p = i;
//		p++;
//	}
//	free(p);//此仍然会报错，free指向的不是起始位置
//
//	p = NULL;
//	return 0;//1.17.52
//}
//11000000000000000
//int main()
//{
//	int* p = (int*)malloc(40);
//	free(p);
//	//  此处如果没有置为空指针 p = NULL;
//	//接下来接着free就会报错
//	//free(p);//error
//
//	//忘记释放内存
//	return 0;
//}
//void test()
//{
//	int flag = 1;
//	int* p = (int*)malloc(100);
//	if (p == NULL)
//	{
//		return ;
//	}
//
//	if (flag)
//	{
//		return;
//	}
//	free(p);
//	p = NULL;//逻辑有问题，先返回之后，无法free掉动态内存
//	//此处内存泄露了
//
//}
//int main()
//{
//	
//	test();
//
//	return 0;
//}
// realloc 其实也可以开辟空间
//int main()
//{
//	realloc(NULL, 40);
//	//此时的realloc等于malloc
//
//	return 0;
//}

//笔试题
//void getmemory(char* p)
//{
//	p = (char*)malloc(100);
//}
//void test(void)
//{
//
//	char* str = NULL;
// //改正 
//	getmemory(str);
//	strcpy(str, "hello world");
//	//str可能是0  ？ 
//	printf("%s",str);
//	//形参是实参的一份临时拷贝，
//	// 此时str仍然为NULL，所以会报警告
//	//程序有可能崩溃
// 内存没有被free掉，会泄露内存
//}
//
//int main()
//{
//
//	
//
//	
//	test();
//
//	return 0;
//}
// //改正
//void * getmemory(char* *p)
//{
//	 *p = (char*)malloc(100);
//	
//}
//char * getmemory()
//{ char *p=(char *)malloc(100);
// return p;
//
//}
//void test(void)
//{
//
//	char* str = NULL;
// 
//	getmemory(&str);
//	strcpy(str, "hello world");
//
//	printf("%s",str);
//	free(malloc);
//}
//int main()
//{
//	test();
//
//
//	return 0;
//}
//char* memory()
//{
//	char* p = (char*)malloc(100);
//	return p;
//
//}
//void test(void)
//{
//	char* str = NULL;
//	str = memory();
//	strcpy(str, "hello bit");
//	printf(str);
//	free(str);
//}
//
//int main()
//{
//
//	test();
//
//	return 0;
//}
//char* memory()
//{
//	char p[] = "hello bit ";
//	return p;
//}
//void test()
//{
//	char* str = NULL;
//	//打印的是乱码
//	str = memory();
//	//返回首元素的地址
//	//出了函数p已经销毁了
//	//所以会瞎打印
//	//野指针
//	printf(str);
//}//返回栈空间的地址的问题
//int main()
//{
//	test();
//
//
//	return 0;
//}
//int test()
//{
//	int a = 10;
//	return a;
//}
//int main()
//{
//	int n = test();
//	printf("hehe");
//	printf("%d", n);//这个时候能打印出hehe，和10
//
//	return 0;
//}
//int* test()
//{
//	int a = 10;
//	return &a;
//
//}
//int main()
//{
//	int* p = test();
//	/*printf("hehe")*/;//有这句话，下一句打印别的数
//	//因为调用过printf了
//
//	printf("%d\n", *p);
//
//
//
//	return 0;
//}
//void memory(char** p, int num)
//{
//	*p = (char*)malloc(num);
//
//}
//void test()
//{
//	char* str = NULL;
//	memory(&str, 100);
//	strcpy(str, "hello");//可以正常打印出hello、
//	// 没有free掉，内存泄漏了
//
//
//
//	printf(str);
//    free(str);
//	str = NULL;
//
//}
//
//int main()
//{
//	test();
//
//	return 0;
//}
//void test()
//{
//	char* str = (char*)malloc(100);
//	strcpy(str, "hello");
//	free(str);
//	//free完应该置为空指针 
//	// str=NULL；
//	// 
//	//把str指向的空间还给操作系统
//	//
//	if (str != NULL)
//	{
//		strcpy(str, "world");//这里形成了非法访问
//		//野指针
//		printf(str);
//	}
//
//}
//int main()
//{
//
//	test();
//
//	return 0;
//}
//柔性数组 9_26
//C99中 结构中最后一个元素允许是未知大小的元素
//1.结构体中
//2.最后一个成员
//3.未知大小
//struct S
//{
//	int n;
//	char c;
//	double d;
//	int arr[]; //未知大小的数组，柔性数组
//};//前面至少有一个其他成员
//sizeof返回的结构体大小不包含柔性数组
//struct s
//{
//	int n;
//	int arr[];
//};
//int main()
//{
//	/*size_t ret = sizeof(s);
//	printf("%zd", ret);*/
//	struct s*p=(struct s*)malloc(sizeof(struct s) + 20 * sizeof(int));
//	if (p == NULL)
//	{
//		perror("malloc");
//		return 1;
//
//
//	}
//	p->n = 100;
//	int i = 0;
//	for (; i < 20; i++)
//	{
//		p->arr[i] = i + 1;
//	}
//	//调整空间 
//	struct s* str=(struct s*)realloc(p, sizeof(struct s) + 40 * sizeof(int));
//	if (str != NULL)
//	{
//		p = str;
//		str = NULL;
//	}
//	else
//	{
//		return 1;
//
//	}
//	for (i=0; i < 40; i++)
//	{
//		printf("%d", str->arr[i]);
//	}//会生成随机值
//	free(p);
//	p = NULL;
//	return 0;
//}
//struct s
//{
//	int n;
//	int * arr;//采用这种方案的时候，会将空间全部释放
//
//};
//int main()
//{
//	struct s* ps = (struct s*)malloc((sizeof(struct s)));
//	if (ps == NULL)
//	{
//		perror("malloc");
//		return 1;
//	}
//	int* tmp = (int*)malloc(20 * sizeof(int));
//	if (tmp != NULL)
//	{
//		ps->arr = tmp;
//}
//	else
//	{
//		return 1;
//	}
//	ps->n = 100;
//	for (int i = 0; i < 20; i++)
//	{
//		ps->arr[i] = i+1;
//	}
//	tmp=(int*)realloc(ps->arr, 40 * sizeof(int));
//	if (tmp != NULL)
//	{
//
//}
//	else
//	{
//
//	}
//	free(ps->arr);
//	free(ps);
//	ps = NULL;
//
//
//	return 0;
//}
//总结c/c++中内存区域的划分

//  内核空间(用户代码不能读写)
// 
// 
// 栈区(局部变量,形参)
// 
// 
// 
// 内存映射段(文件映射,动态库,匿名映射)
// 
// 
//堆区(动态申请的内存) 
// 
// 
// 
// 数据段 静态区(全局变量,静态变量static)
// 
// 
// 代码区 不能修改的
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
// 
//
//int main()
//{
//	int a, b, c;
//	int max;
//	scanf("%d%d%d", &a, &b, &c);
//	if (a > b)
//	{
//		max = a;
//
//	}
//	else
//	{
//		max = b;
//
//	}
//	if (c > max)
//	{
//		max = c;
//	}
//	printf("%d", max);
//
//
//	return 0;
//}
//
//int main()
//{
//	int a, a1, b, b1, c, c1, d, d1;
//	scanf("%d%d%d%d%d%d%d%d", &a, &a1, &b, &b1, &c, &c1, &d, &d1);
//	if (d == a && d1 == a1 || d == b && d1 == a1 || d == c && d1 == c1)
//	{
//		printf("%d", 4);
//	}
//	else if()
//	{
//
//	}
//
//	return 0;
//}
//（1）如果是素数，则输出 “y”；
//
//（2）如果不是素数，则输出其最小素数因子与另外一个数；比如：35不是素数，则输出 “5 * 7”。
//
//要求编写一个函数，判断素数及求最小素数因子。
//
//void jdgprime(int n) {          }
//
//输入（Input）：
//
//一个正整数（不考虑输入1时的情况）
//
//输出（Output）：
//
//如果是素数，则输出“y”；如果不是素数，则输出其最小素数因子与另外一个数。
//
//提示（Hint）：
//
//程序的前缀代码已经给出。
//
//示例1（Sample）：
//
//输入（Input） :
//
//23
//
//输出（Output）：
//
//y
//
//示例2（Sample）：
//
//输入（Input） :
//
//63
//
//输出（Output） :
//
//	3 * 21
//
//
//int main()
//
// {
//	printf("    1");
//
//	return 0;
//
// }
//int main()
//{
//
//	char arr[100000];
//	std::cin >> arr;
//	std::cout << arr;
//
//	return 0;
//}
//int main()
//{
//	char arr[1100];
//	strcpy(arr, "hello world");
//	printf(arr);
//
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	if (a >= 100 || a <= 0)
//	{
//		printf("%d error", a);
//
//	}
//	else
//	{
//		for (int i = 1; i <a+1 ; i++)
//		{
//			printf("%d.hello world\n", i);
//		}
//	}
//
//
//	return 0;
//}

//int main()
//{
//	int a = 0;
//	printf("%d", a);
//	scanf("%d", &a);
//	printf("%d", a);
//
//
//	return 0;
////}
//#define MAX_SIZE 2+3
//struct _Record_Struct
//{
//
//	unsigned char Env_Alarm_ID : 4;
//	unsigned char Para1 : 2;
//	unsigned char state;
//	unsigned char avail : 1;
//}*Env_Alarm_Record;
//struct _Record_Struct* pointer = (struct _Record_Struct*)malloc(sizeof(struct _Record_Struct) * MAX_SIZE);
//int main()
//{
//	unsigned char puc[4];
//	struct tagPIM
//	{
//		unsigned char ucPim1;
//		unsigned char ucData0 : 1;
//		unsigned char ucData1 : 2;
//		unsigned char ucData2 : 3;
//	}*pstPimData;
//	pstPimData = (struct tagPIM*)puc;
//	memset(puc, 0, 4);
//	pstPimData->ucPim1 = 2;//0000 0010
//	pstPimData->ucData0 = 3;//0000 0011
//	pstPimData->ucData1 = 4;//0000  0100
//	pstPimData->ucData2 = 5;//0000 0101 位段表示存储的字节个数
//
//   //0 0 0 0 0 0 1 0  0 0 1 0 1 0 0 1        //02 29 00 00 
//	printf("%02x %02x %02x %02x\n", puc[0], puc[1], puc[2], puc[3]);
//	return 0;
//}
//校招时部分企业笔试将禁止编程题跳出页面，为提前适应，练习时请使用在线自测，而非本地IDE。
//描述
//变种水仙花数 - Lily Number：把任意的数字，从中间拆分成两个数字，比如1461 可以拆分成（1和461）, （14和61）, （146和1), 如果所有拆分后的乘积之和等于自身，则是一个Lily Number。
//
//例如：
//
//655 = 6 * 55 + 65 * 5
//
//1461 = 1 * 461 + 14 * 61 + 146 * 1
//12 345
//求出 5位数中的所有 Lily Number。
//
// 10 001
//输入描述：
//无
//输出描述：
//110 00
// 一行，5位数中的所有 Lily Number，每两个数之间间隔一个空格。
//int main()
//{
//	int n = 10000;
//	int d = 10000;
//	int count = 4;
//	int sum = 0;
//	for (; n <= 100000; n++)
//	{
//		int j = n;
//		sum = 0;
//		again:
//		while (count)//4
//		{
//			int x = n - (n / d) * d;
//			if (x<=d/10)
//			{
//				d /= 10;
//				count--;
//				goto again;
//			}
//		
//			
//			if (x < d / 10)
//			{
//				d /= 10;
//				count--;
//				goto again;
//
//			}
//			sum += x * (n / d);
//
//			d /= 10;
//
//			count--;
//
//
//		}
//		if (sum == j)
//		{
//			printf("%d ", j);
//		}
//	}
//10001
///10000


//	return  0;
//}  //倒着做会比正着做简单
//int main()
//{
//	int n = 0;
//	for (n = 10000; n <= 99999; n++)
//	{
//		int j;
//		int sum = 0;
//	
//	 
//		for (j = 10; j <= 10000; j *= 10)
//		{
//			sum += (n/ j) * (n% j);
//		}
//		if (sum == n)
//		{
//			printf("%d ", n);
//		}
//	}
//
//
//
//
//	return 0;
//}
//有一个整数序列（可能有重复的整数），现删除指定的某一个整数，输出删除指定数字之后的序列，序列中未被删除数字的前后位置没有发生改变。
//
//数据范围：序列长度和序列中的值都满足
//1
//≤
//�
//≤
//50
//1≤n≤50
//输入描述：
//第一行输入一个整数(0≤N≤50)。
//
//第二行输入N个整数，输入用空格分隔的N个整数。
//
//第三行输入想要进行删除的一个整数。
//
//输出描述：
//输出为一行，删除指定数字之后的序列。
//示例1
//输入：
//6
//1 2 3 4 5 9
//4
//复制
//输出：
//1 2 3 5 9
//复制
//示例2
//输入：
//5
//1 2 3 4 6
//5
//复制
//输出：
//1 2 3 4 6
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int arr[50];
//	for (int i = 0; i < n; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int find = 0;
//	scanf("%d", &find);
//	for (int j = 0; j < n; j++)
//	{
//		if (arr[j] != find)
//		{
//			printf("%d ", arr[j]);
//
//		}
//
//	}
//
//
//	return 0;
//}
//int main()
//{
//	union
//	{
//		short k;
//		char i[2];
//	}*s, a;
//	s = &a;
//	s->i[0] = 0x39;
//	s->i[1] = 0x38;
//	printf("%x\n", a.k);//3839
//	// 
//	return 0;
//}

//enum ENUM_A
//{
//	X1,//0
//	Y1,//1
//	Z1 = 255,//255
//	A1,//256
//	B1,//257
//};
//int main()
//{
//	enum ENUM_A enumA = Y1;
//	enum ENUM_A enumB = B1;
//	printf("%d %d\n", enumA, enumB);
//	return 0;
////}
//void GetMemory(char* p)
//{
//	p = (char*)malloc(100);
//}
//void Test(void)
//{
//	char* str = NULL;
//	GetMemory(str);
//	strcpy(str, "hello world");
//	printf(str);
//}
//int main()
//{
//	malloc(10 * sizeof(int));
//	calloc(10, sizeof(int));
//	free(malloc);
//	free(calloc);
//
//	return 0;
//}
//给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：
//
//	ans[i] == nums[i]
//	ans[i + n] == nums[i]
//	具体而言，ans 由两个 nums 数组 串联 形成。
//
//	返回数组 ans 。
//
//
//
//	示例 1：
//
//	输入：nums = [1, 2, 1]
//	输出：[1, 2, 1, 1, 2, 1]
//	解释：数组 ans 按下述方式形成：
//	- ans = [nums[0], nums[1], nums[2], nums[0], nums[1], nums[2]]
//	- ans = [1, 2, 1, 1, 2, 1]
//	示例 2：
//
//	输入：nums = [1, 3, 2, 1]
//	输出：[1, 3, 2, 1, 1, 3, 2, 1]
//	解释：数组 ans 按下述方式形成：
//	- ans = [nums[0], nums[1], nums[2], nums[3], nums[0], nums[1], nums[2], nums[3]]
//	- ans = [1, 3, 2, 1, 1, 3, 2, 1]
//int* getConcatenation(int* nums, int numsSize, int* returnSize)
//{
//	int* ans = (int *)malloc(numsSize *2* sizeof(int));
//
//	for (int i = 0; i <numsSize;i++ )
//	{
//		int n = numsSize;
//		ans[i] = nums[i];
//		ans[i + n] = nums[i];
//
//	}
//	*returnSize = numsSize * 2;
//
//
//
//	return ans ;
//}

//int main()
//{
//	printf("%d,%d", 3, 5);
//
//
//	return 0;
//}
//int main()
//{
//	char arr[1100];
//	strcpy(arr, "hello world");
//	printf(arr);
//
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	if (a >= 100 || a <= 0)
//	{
//		printf("%d is wrong", a);
//
//	}
//	else
//	{
//		for (int i = 1; i <a+1 ; i++)
//		{
//			printf("line%d:hello world\n", i);
//		}
//	}
//
//
//	return 0;
//}
//int main()
//
//{
//
//	int i;
//	for (int i = 0; i < 5; i++)
//	{
//		printf("a");
//	}
//	return 0;
//}
//使用malloc函数模拟开辟一个二维数组
//
//作业内容
//使用malloc函数模拟开辟一个3 * 5的整型二维数组，开辟好后，使用二维数组的下标访问形式，访问空间。

// 0 0 0 0 0 
// 0 0 0 0 0
// 0 0 0 0 0 
//int main()
//{//
//	int* *p = (int**)malloc(3 * sizeof(int*));
//	//先开辟二级指针 再去进一步创建行
//	int i = 0;
//	for ( i = 0; i < 3; i++)
//	{
//		p[i] = (int*)malloc(5 * sizeof(int));
//	}
//	for (i=0; i < 3; i++)
//	{
//		for (int j = 0; j < 5; j++)
//		{
//			p[i][j] = 5 * i + j;
//		}
//
//	}
//
//	for (i=0; i < 3; i++)
//	{
//		for (int j = 0; j < 5; j++)
//		{
//			printf("%d ", p[i][j]);
//		}
//		printf("\n");
//	}
//	
//	
//	return 0;
//}

//union s1
//{
//	char a;
//	int b;
//
//
//}s2;
//
//
//int main()
//{
//	s2.b = 1;
//	printf("%x", s2.a);
//
//	return 0;
//}


//创建二维数组
//int main()
//{
//	int** p = (int**)malloc(3 * sizeof(int*));
//	int i;
//	for ( i = 0; i < 3; i++)
//	{
//		p[i] = (int*)malloc(5 * sizeof(int));
//
//	}
//	for (i = 0; i < 3; i++)
//			{
//				for (int j = 0; j < 5; j++)
//				{
//					p[i][j] = 5 * i + j;
//				}
//		
//			}
//		
//			for (i=0; i < 3; i++)
//			{
//				for (int j = 0; j < 5; j++)
//				{
//					printf("%d ", p[i][j]);
//				}
//				printf("\n");
//			}
//	//释放内存
//	for (int j = 0; j < 3; j++)
//	{
//		free(p[j]);
//}
//	free(p);
//	p = NULL;
//
//	return 0;
//}
//文件操作
//int main()
//{
//	int a = 10000;
//	FILE* pf = fopen("text.txt", "wb");
//	fwrite(&a, 4, 1, pf);
//	fclose(pf);
//	pf = NULL;
//
//	return 0;
//}
//流 
//标准流
//打开流
//读写
//关闭流
//scanf  键盘
//printf  屏幕
//int main()
//{
//	int a;
//	std::cin >> a;
//	std::cout << a;
//	return 0;
//
//}
//FILE
//不同编译器FILE类型包含的内容不相同，但是大同小异
//文件的打开和关闭 
//fclose
//fopen
//文件的操作
//打开 读写 关闭
///*FILE* fopen(const char* filename, const char* */mode);
//int main()
//{
	//打开
	//r 只读
	//w 只写 会把原来的文件清空掉
	//a 追加
	//FILE*pf=fopen(" C:\\Users\\郭英杰\\Desktop\\data.txt ", "w");
	//绝对路径
	//FILE* pf = fopen(".\\..\\data,txt", "w");
	//相对路径
//
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//关闭
//	fclose(pf);
//	pf = NULL;
//
//
//	return 0;
//}
	//以读的形式打开只能读
//文件的顺序读写
//int main()
//{
//	FILE*pf=fopen("data.txt","r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//int fputc (int character,FILE*stream)
//	/*fputc('a', pf);
//	fputc('b', pf);
//	fputc('c', pf);
//	fputc('d', pf);
//	fputc('e', pf);
//	fputc('a', pf);
//	fputc('a', pf);*/
//	/*for (int i = 'a'; i <= 'z'; i++)
//	{
//		fputc(i, pf);
//	}*/
//
//	/*close(pf);*/
//	int ch = fgetc(pf);
//	printf("%c", ch);
//	pf = NULL;
//	return 0;
//}

//fgetc
// int fgetc (FILE*stream)
//读取正常的时候，返回读取到的字符的ASCII值
//失败的时候会返回EOF

//stdin 输入流
//读的形式打开文件

//int main()
//{
//	int ch = fgetc(stdin);//从键盘上（标准输入流）读取
//	fputc(ch, stdout);//将字符输出（写）到屏幕上（标准输出流）
//
//
//
//
//
//	return 0;
//}
//文件操作2
//fgets
//fputs 
//int fputs(const char *str,FILE*stream)
//int main()
//{
//	//打开文件
//	FILE* pf = fopen("data.txt","r");
//	//写文件
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//fputs("I am a student\n",pf);
//	char arr[20] = { 0 };
//	fgets(arr, 10, pf);//会读num-1个字符    因为有\0
//	printf(arr);//如果遇到\n会停下来
//	//fputs("are you ok?\n", pf);
//	//char * fgets(char *str,int num,FILE*stream);
//
//	fclose(pf);
//	pf = NULL;
//	return 0;
//}
//int main()
//{
//	char arr[20] = { 0 };
//	fgets(arr, 20, stdin);
//	//fgetc(stdin);
//	fputs(arr, stdout);
//
//
//
//
//}
//struct s
//{
//	char name[20];
//	int age ;
//	float score ;
//
//};
//int main()
//{
//	struct s s1 = { "list",18,18.8f };
//	//打开文件
//	FILE* pf = fopen("data.txt","w");
//	//写文件
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//int printf(const char* format,.....)
//	//int fprintf(FILE *stream ,const char *format,.....)
//	// ....叫可变参数
//	fprintf(pf, "%s,%d,%lf", s1.name, s1.age, s1.score);
//
//	
//	
//
//	fclose(pf);
//	pf = NULL;
//	return 0;
//}
//struct s
//{
//	char name[20];
//	int age;
//	float score;
//
//};
//int main()
//{
//	struct s s1 = { 0 };
//	//打开文件
//	FILE* pf = fopen("data.txt", "r");
//	//写文件
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//int printf(const char* format,.....)
//	//int fprintf(FILE *stream ,const char *format,.....)
//	// ....叫可变参数
//	fscanf(pf, "%s,%d,%lf", s1.name, &(s1.age), &(s1.score));
//
//	//printf("%s %d %f\n", s1.name, s1.age, s1.score);
//	fprintf(stdout, "%s %d %f\n", s1.name, s1.age, s1.score);
//
//
//	fclose(pf);
//	pf = NULL;
//	return 0;
//}
// scanf/printf 针对标准输入流和标准输出流的格式化输入输出函数
//fscanf/fprintf 针对所有输入流/输出输出流的 ..
//sscanf/sprintf
//sprintf
//将格式化的数据写到字符串中
//struct s
//{
//	char name[20];
//	int age;
//	float score;
//};
//int main()  
//{
//	char arr[100];
//	struct s s1 = { "wangwu",23,66 };
//	struct s tmp = { 0 };
//
//	
//	sprintf(arr, "%s %d %f", s1.name, s1.age, s1.score);
//	//printf(arr);
//	//从arr中提取格式化的数据,存放在tmp中
//	int ret=sscanf(arr,"%s %d %f", tmp.name, &(tmp.age), &(tmp.score));
//	printf("%d\n", ret);
//	printf("%s %d %f", tmp.name, (tmp.age), (tmp.score));
//	return 0;
//}
//sscanf 是从字符串中提取格式化的数据
//将字符串转化为格式化的数据]
//fread 二进制输入
//fwrite 二进制输出

//struct s
//{
//	char name[20];
//	int age;
//	float score;
//};
//int main()
//{
//	//struct s s1 = { "cuihua",20,88.8f };
//	struct s s1 = { 0 };
//	FILE *pf=fopen("data.txt", "rb");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//size_t fwrite(const void *ptr,size_t size,size_t count ,FILE*stream);
//	// 
//	//fwrite(&s1, sizeof(struct s), 1, pf);
//	//因为以2进制存放,所以看不出来
//	fread(&s1, sizeof(struct s), 1, pf);
//	// 从文件中读取1个大小为sizeof的个字节的数据放到是中
//	printf("%s %d %f", s1.name, s1.age,  s1.score);
//	 
//
//	fclose(pf);
//	pf = NULL;
//
//	return 0;
//}
//文件的随机读写
//fseek
// 
//int fseek(FILE*stream,long int offset,int origin);
//
//int main()
//{
//	FILE* pf = fopen("data.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//int ch = 0;
//	//ch=fgetc(pf);
//	//printf("%c", ch);//a 
//	//ch = fgetc(pf);
//	//printf("%c", ch);//b 因为光标向下移动
//	//fseek(pf, 4, SEEK_SET);
//	fseek(pf, -3, SEEK_END);
//	int ch = fgetc(pf);
//	printf("%c", ch);//e 
//	//fseek(pf, 4, SEEK_CUR);
//	//abcdefg
//	fclose(pf);
//	pf = NULL;
//
//
//
//
//
////}
// int main()
//{
//	FILE* pf = fopen("data.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//int ch = 0;
//	//ch=fgetc(pf);
//	//printf("%c", ch);//a 
//	//ch = fgetc(pf);
//	//printf("%c", ch);//b 因为光标向下移动
//	//fseek(pf, 4, SEEK_SET);
//	fseek(pf, -3, SEEK_END);
//	int ch = fgetc(pf);
//	printf("%c", ch);//e 
//	//fseek(pf, 4, SEEK_CUR);
//	//abcdefg
//	//读完e之后光标来到了e之后所以偏移量是5
//	//int ret=ftell(pf);
//	//printf("%d\n", ret);
//	rewind(pf);//回到了起始位置,打印了a
//
//	ch = fgetc(pf);
//	printf("%c", ch);
//	fclose(pf);
//	pf = NULL;
//}
// //rewind 回到起始位置
//  
//EOF end of file 文件结束标志
//feof不是判断文件是否结束
// 当文件读取结束的时候,判断结束的原因是否是遇到文件末尾结束
//
//int main()
//{
//	int c;
//	FILE* pf = fopen("data.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	while ((c = fgetc(pf)) != EOF)
//	{
//		putchar(c);
//	}
//	if (ferror(pf))
//	{
//		puts("error");
//			
//	}
//	else if (feof(pf))
//	{
//		puts("end of file");
//	}
//
//
//
//	return 0;
//}
//int main()
//{
//	int a, b;
//	scanf("%d%d", &a, &b);
//	int c = (a * 10 + b) / 16;
//	int d = a * 10 + b - c*16;
//	printf("%d\n%d", c, d);
//
//
//	return 0;
//}
////将Class.cpp复制到data.txt
//int main()
//{
//	//打开文件
//	FILE*pf=fopen("Class.cpp", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//
//	}
//	FILE*pfwrite=fopen("data.txt", "w");
//	if (pfwrite == NULL)
//	{
//		perror("fopen");
//		fclose(pf);
//		return 1;
//	}
//	//读写文件
//	int ch = 0;
//	while ((ch = fgetc(pf)) != EOF)
//	{
//		fputc(ch, pfwrite);
//
//	}
//	//关闭文件
//
//	fclose(pf);
//	pf = NULL;
//	fclose(pfwrite);
//	pfwrite = NULL;
//	
//
//
//
//
//	
//
//	return 0;
//}
//int main()
//{
//	FILE* pf = fopen("data.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	int ch;
//		while ((ch = fgetc(pf)) != EOF)
//	{
//	
//
//	}
//	printf("%c\n", ch);
//	int ret = feof(pf);//feof当没有遇到文件末尾的时候就会返回0,遇到了就会返回一个非0的数
//	printf("%d", ret);
//	return 0;
//}
//   缓冲区fflush
//预定义符号
//int main()
//{
//	printf("%s\n", __FILE__);//文件所在位置
//
//	printf("%d\n", __LINE__);//行号
//
//	printf("%s\n", __DATE__);//日期
//
//	printf("%s\n", __TIME__);//时间
//
//	return 0;
//}
//#define M 1+2
//预编译阶段会把#define删掉 进行替换
//#define STR "hehe"
//#define u unsigned
////typedef unsigned int ui;
//
//int main()
//{
//	ui a = 5;
//	int a = M;
//	int arr[M] = { 0 };
//	printf("%d\n", M*3);//7而不是9
//	printf(STR);
//	return 0;
//}
// 
////
//#define CASE break;case
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	switch (n)
//	{
//		case1:
//		
//	CASE2:
//
//		CASE3:
//
//	}
//
//
//	return 0;
//}
// \ 续航符
//#define a printf("%d,\
//%c")
//#define 加不加;呢?
//有时候加上不会有什么问题,但是不建议加
//加上可能导致出问题
//#define M 100; //整个替换过去 把M换成100;
//int main()
//{
//	int a = M;
//
//	return 0;
//}//总结 不加就完了
//#define 定义宏
//宏其实是有参数的



//实现一个宏 求平方
//#define SQUARE(n) n*n//square 平方
//int main()
//{
//	int x = 0;
//	scanf("%d", &x);
//	int ret = SQUARE(x);
//	printf("%d", ret);
//	return 0;
//}


//
//#define SQUARE(n) n*n//square 平方
//int main()
//{
//	//int x = 0;
//	//scanf("%d", &x);
//	int ret = SQUARE(5+1);//11  5+1*5+1=11;
//	//宏的参数不会计算,直接替换
//	printf("%d", ret);
//	return 0;
//}

//
//#define SQUARE(n) (n*n)//square 平方
//int main()
//{
//	//int x = 0;
//	//scanf("%d", &x);
//	int ret = SQUARE(5 + 1);//36 不要吝啬括号
//		printf("%d", ret);
//	return 0;
//}
//#define DOUBLE(n) (n+n)
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = DOUBLE(n);
//	printf("%d", ret);
//	ret = 10 * DOUBLE(5);
//	printf("%d", ret);//55 不要吝啬括号
//	//带上括号 就正确了 一定不要吝啬括号,但也别瞎带
//
//	return 0;
//}
//
//int main()
//{
//
//
//	for(;;)
//		//可以省略掉
//		//判断部分省略掉不写,就意味着判断条件恒为真,死循环了
//
//	return 0;
//}
////带有副作用的宏参数
//int main()
//{
//	int a = 1;
//	int b = 10;
//	a = b + 1;//a=11 b=10
//	a = ++b;//a=11,b=11;
//
//
//	return 0;
//}

//写一个宏 求两个数的较大值
//#define MAX(x,y) ((x)>(y)?(x):(y))
//int main()
//{
//	int a = 3;
//	int b = 5;
//	int m = MAX(a++, b++);
//	//此时会自增两次
//	printf("%d", m);
//
//	return 0;
//}//宏不能递归
////字符串常量的内容不会被替换
/////1 10 52


//学吧
//最近我看到一个街头小游戏，感觉很有意思。在一个不透明的布袋里面有三种颜色的小球（蓝色、黄色、红色），每个小球各8个，一共24个小球。每次游戏，从24个小球中取出12个，然后根据三种颜色的个数组合，得到相应的钞票奖励，中奖规则如下：
//
//
//
//
//例如：摸出8个红球、4个黄球，那么组合就是840，得到100元；如果摸出5个篮球、1个黄球、6个红球，组合为651，得到1元；但是如果摸出的组合是543，那我就要给摊主10元。
//
//乍一看，12种组合都可以得到钱，只有1种付费，好像是只赚不赔的买卖？这样的游戏如果你看到了，你会玩吗？
//
//请模拟计算，玩1次的他会赚多少元钱的平均值，即数学期望（最后结果保留2位小
//int main()
//{
//
//
//
//	return 0;
//} 本质上就是一个数学题 没必要写
//把这个问题一般化，即输入4个整数，红球数量，黄球数量，蓝球数量， 玩家摸出球的数量。
/*
输出：每种数量组合的情况（按每种数量组成的数字，从小到大排序），及其概率（保留10位小数）。

样例输入

8

8

8

12

样例输出：

4_4_4 : 0.13
5_4_3 : 0.49
5_5_2 : 0.10
6_3_3 : 0.10
6_4_2 : 0.12
6_5_1 : 0.03
6_6_0 : 0.00
7_3_2 : 0.03
7_4_1 : 0.01
7_5_0 : 0.00
8_2_2 : 0.00
8_3_1 : 0.00

8_4_0 : 0.00

//格式说明：例如8_3_1 表示，颜色最多的有8个，第二多的3个，第三多的有1个 ， 然后是 “ : " 两个有空格， *//*最后一个保留2位小数的小数概率。 排序是，颜色最多球，第二多，第三多数量排序，用下划线分割。*/
//不想算 用函数写出cnm的算法 带入
//int main()
//{
//	char a = 'a';
//	for (int i = 9; i > 0; i = i - 2)
//	{
//		printf("*");
//	}
//	for (a; a <= 'z'; a = a + 2)
//	{
//
//	}
//
//	return 0;
//}
//int main()
//{
//	int a[3];
//	for (int i = 0; i < 3; i++)
//	{
//		a[i] = getchar();
//	}
//	for (int j = 0; j < 3; j++)
//	{
//		putchar(a[j]);
//	}
//	return 0;
//}

//#include <iostream>
//int main()
//{
//	char a, b, c;
//	std::cin >> a >> b >> c;
//	std::cout << a << b << c;
//	
//
//
//	return 0;
//}
//int main()
//{
//	char a = 'A';
//	int i=9;
//	int j = 0;
//	for ( i = 9; i > 0; i = i - 2)
//	{
//		for ( j = 0; j<i; j++)
//		{
//			printf("*");
//		}
//		printf("\n");
//
//
//
//
//
//
//	}
//	return 0;
//}
//int main()
//{
//	char a, b, c;
//	scanf("%c %c %c", &a, &b, &c);
//	printf("%c%c%c", a, b, c);
//
//	return 0;
//}
//int main()
//{
//	printf("*********A*********");
//	printf("********BCD********");
//	printf("*******EFGHI*******");
//	printf("******JKLMNOP******");
//	printf("*****QRSTUVWXY*****");
//	printf("****ZABCDEFGHIJ****");
//	printf("***KLMNOPQRSTUVW***");
//	printf("**XYZABCDEFGHIJKL**");
//	printf("*MNOPQRSTUVWXYZABC*");
//	printf("**DEFGHIJKLMNOPQR**");
//	printf("***STUVWXYZABCDE***");
//	printf("****FGHIJKLMNOP****");
//	printf("*****QRSTUVWXY*****");
//	printf("******ZABCDEF******");
//	printf("*******GHIJK*******");
//	printf("********LMN********");
//	printf("*********O*********");
//
//
//	return 0;
//}
//int main()
//{
//	char a = 'A';
//	int i=9;
//	int j = 0;
//	int d = 1;
//	int g = 0;
//	int count = 1;
//	int w = 0;
//	int e = 0;
//	for (i = 9; i > 0; i = i --)
//	{
//		for (j = 0; j < i; j++)
//		{
//			printf("+");
//		}
//		while (d)
//		{
//			printf("%c", a);
//			d--;
//			a++;
//			if (a == 'Z' + 1)
//			{
//				a = 'A';
//			}
//
//		}
//		count += 2;
//		d = count;
//		for (g= 0; g < i; g++)
//		{
//			printf("+");
//		}
//
//		printf("\n");
//		
//	}
//	int f = 15;
//	
//	int count1 = f;
//	char z='D';
//	for (w = 1; w < 9; w++)
//	{
//		for(e = -1; e < w; e++)
//		{
//			printf("+");
//		}
//		while (f)
//		{
//			printf("%c", z);
//			if (z == 'Z' + 1)
//			{
//				z = 'A';
//			}
//			f--;
//			z++;
//		}
//		count1 -= 2;
//		f = count1;
//		for (int p = -1; p < w; p++)
//		{
//			printf("+");
//		}
//		printf("\n");
//	}
//	return 0;
//}
//	printf("**DEFGHIJKLMNOPQR**");
//	printf("***STUVWXYZABCDE***");
//	printf("****FGHIJKLMNOP****");
//	printf("*****QRSTUVWXY*****");
//	printf("******ZABCDEF******");
//	printf("*******GHIJK*******");
//	printf("********LMN********");
//	printf("*********O*********");
//x2除以391余数为50，求满足该条件，且小于等于输入整数以内的正整数x。
//
//输入（Input）：
//
//一个整数
//
//输出（Output）：
//
//符合条件的一组数，用空格分隔
//
//示例（Sample）：
//
//输入（Input）：
//
//200
//
//输出（Output）：
//
//21 140
//int main()
//{
//	int n;
//	scanf("%d", &n);
//	for (int i = 1; i <= n; i++)
//	{
//		if (i * i % 391 == 50)
//		{
//			printf("%d ", i);
//		}
//	}
//
//
//	return 0;
//}
//完全平方即用一个整数乘以自己，例如1 * 1，2 * 2，3 * 3等，依此类推。若一个数能表示成某个整数的平方的形式，则称这个数为完全平方数。
//
//一个正整数，它加上 100 后是一个完全平方数，再加上 168 又是一个完全平方数。输入一个正整数，求出满足上述条件且小于等于这个正整数的所有数。
//
//输入（Input）：
//
//一个正整数
//
//输出（Output）：
//
//满足题目要求的一组数（每行输出一个）
//
//示例（Sample）：
//
//输入（Input）：
//
//100
//
//输出（Output）：
//
//21
//int judge(int a)
//{
//	for (int j = 0; j < a; j++)
//	{
//
//		if (j * j == a)
//		{
//			return 1;
//		}
//
//	}
//	return 0;
//}
//int main()
//{
//	int n;
//	scanf("%d", &n);
//	
//	for (int i = 1; i <= n; i++)
//	{
//		if (judge(i + 100) + judge(i + 268) == 2)
//		{
//			printf("%d ", i);
//		}
//	}
//
//
//	return 0;
//}
//输入一个正整数，找出满足下面条件的所有整数：
//
//（1）小于该整数；
//
//（2）各位数字相同；
//
//（3）相同位数。
//
//要求：每输出一个数换行。
//
//输入（Input）：
//
//一个整数
//
//输出（Output）：
//
//小于该整数的各位数字相同的所有数
//
//示例（Sample）：
//
//输入（Input）：
//
//231
//
//输出（Output）：
//
//111
//
//222
//int sum(int count,int c)
//{
//	int sum1 = 0;
//	while (count+1)
//	{
//		 sum1+= (int)pow(10,count-1) * c;
//		 count--;
//	}
//	return sum1;
//}
//int main()
//{
//	int a;
//	scanf("%d",  &a);
//	int d = a;
//	int count = 0;
//	while (d)
//	{
//		count++;
//		d/=10;
//	}
//
//	int c = a;
//
//	int num = c / (int)pow(10, count-1);
//
//	for (int k = 1; k <= num; k++)
//	{
//		if (sum(count, k) < a)
//		{
//			printf("%d\n", sum(count, k));
//		}
//	}
//	
//	return 0;
//}
//
//10个数，从小到大排序平输出

//int int_tmp(const void* p1, const void* p2)
//{
//	return *(int*)p1 - *(int*)p2;
//}
//int main()
//{
//	int arr[10];
//	for (int i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	qsort(arr, sz, sizeof(arr[0]), int_tmp);
//	for (int j = 0; j < 10; j++)
//	{
//		printf("%d ", arr[j]);
//	}
//	return 0;
//}
//扫雷

//
//int main()
//{
//
//	int x, y, minecount;
//	scanf("%d%d%d", &x, &y, &minecount);
//	int mine[10];
//	for (int j = 0; j < 10; j++)
//	{
//		scanf("%d", &mine[j]);
//	}
//	int board[10][10] = { 0 };
//
//
//	int x2, y2;
//	int find = 0;
//	while (minecount)
//	{
//		y2 = mine[find] / (x);
//		x2 = mine[find] - y2 * (x);
//		board[y2 + 1][x2 + 1] = -1;
//
//
//		find++;
//		minecount--;
//	}
//	for (int t = 1; t < x + 1; t++)
//	{
//
//		for (int u = 1; u < y + 1; u++)
//		{
//			int sum = 0;
//			if (board[t][u] != -1)
//			{
//
//				for (int b = -1; b < 2; b++)
//				{
//					for (int k = -1; k < 2; k++)
//					{
//						if (board[t + b][u + k] == -1)
//						{
//							sum++;
//						}
//					}
//				}
//				board[t][u] = sum;
//			}
//		}
//	}
//
//
//	for (int q = 1; q < x + 1; q++)
//	{
//		for (int w = 1; w < y + 1; w++)
//		{
//			printf("%d ", board[q][w]);
//		}
//		printf("\n");
//	}
//
//	return 0;
//
//
//}

 //
 // //找鞍点
//每一行中最大的元素
//同时也是每一列中最小的元素
//找到每一行中最大的元素max[]
//扎到每一列最小的元素 min[]
//遍历两个数组,看看是否相等
//int main()
//{
//
//	int a, b;
//	scanf("%d%d", &a, &b);
//	int arr[a][b] = {0};
//	int max[a] = {0};
//	int min[b];
//	for (int i = 0; i < a; i++)
//	{
//		for (int j = 0; j < b; j++)
//		{
//			scanf("%d", &arr[i][j]);
//				
//		}
//	}
//	int s = 0;
//	int q;
//	while (s < a)
//	{
//		q = 0;
//		for (q = 0; q < b; q++)
//		{
//
//			if (arr[s][q] > max[s])
//			{
//				max[s] = arr[s][q];
//			}
//
//		}
//		
//
//		s++;
//	}
//
//	int f = 0;
//	while (f <b)
//	{
//		min[f] = 10000;
//		for (int l = 0; l < a; l++)
//		{
//			if (arr[l][f] < min[f])
//			{
//				min[f] = arr[l][f];
//			}
//			
//		}
//	
//
//		f++;
//	}
//	for (int m = 0; m < a; m++)
//	{
//		for (int mi = 0; mi < b; mi++)
//		{
//			if (max[m] == min[mi])
//			{
//				printf("arr[%d][%d]=%d", m,mi ,max[m]);
//				return 1;
//
//			}
//			
//		}
//
//	}
//	printf("no");
//	return 0;
//}

//幻方算法
//每行 每列 对角线上的元素 之和相等
// ? 不会



//将一个字符串中的元音字母（a、e、i、o、u）复制到另一个字符串，然后按照ASCII码从小到大的顺序输出。
//
//输入（Input）：
//
//一行字符串
//
//输出（Output）：
//
//输入字符串中的元音字母（按照ASCII码从小到大的顺序）
//
//提示（Hint）：
//
//考虑输入字符串中包含大、小写字母
//
//示例（Sample）：
//
//输入（Input）：
//
//uabE
//
//输出（Output）：
//
//Eau
//思路 先找出所有1符合条件的
//再去 排序
//int char_imp(const void* p1,const void* p2)
//{
//	return *(char*)p1 - *(char*)p2;
//}
//int main()
//{
//	char arr[10000];
//	char* pa = arr;
//	std::cin >> arr;
//	char arr1[10000];
//	char* pa1 = arr1;
//	
//	while (*pa)
//	{
//		if (tolower(*pa) == 'a' || tolower(*pa) == 'e' || tolower(*pa) == 'i' || tolower(*pa) == 'o' ||tolower(*pa) == 'u')
//		{
//			 *pa1= *pa;
//		   pa1++;
//			pa++;
//		}
//		else
//		{
//			pa++;
//		}
//	}
//	   
//		*pa1 = '\0';
//	// u a e \0
//	
//		int len = strlen(arr1);
//		pa1 -= len;
///*	qsort(arr1, len, sizeof(arr1[0]), char_imp);*//注意 int_tmp返回值是int,但是return相减去的类型由排序类型决定
//		for (int i = 0; i < len-1 ; i++)
//		{
//			int j = 0;
//			for (; j < len - i - 1; j++)
//			{
//				if (pa1[j] > pa1[j+1])
//				{
//					char tmp = pa1[j];
//					pa1[j] = pa1[1+j];
//					pa1[j + 1] = tmp;
//				}
//			}
//		}
//	std::cout << arr1;
//
//
//	return 0;
//}
//int int_tmp(const void* p1, const void* p2)
//{
//	return *(char*)p1 - *(char*)p2;
//}
//int main()
//{
//	char arr1[] = "aEc";
//	int len=strlen(arr1);
//	qsort(arr1, len, sizeof(arr1[0]), int_tmp);
//	std::cout << arr1;
//	return 0;
//}
//int char_imp(const void* p1,const void* p2)
//{
//	return *(char*)p1 - *(char*)p2;
//}
//int main()
//{
//	char arr[10000];
//	char* pa = arr;
//	std::cin >> arr;
//	char arr1[10000];
//	char* pa1 = arr1;
//	
//	while (*pa)
//	{
//		if (tolower(*pa) == 'a' || tolower(*pa) == 'e' || tolower(*pa) == 'i' || tolower(*pa) == 'o' ||tolower(*pa) == 'u')
//		{
//			 *pa1= *pa;
//		   pa1++;
//			pa++;
//		}
//		else
//		{
//			pa++;
//		}
//	}
//	   
//		*pa1 = '\0';
//	// u a e \0
//	
//		int len = strlen(arr1);
//		pa1 -= len;
//	qsort(arr1, len, sizeof(arr1[0]), char_imp);
//		
//	std::cout << arr1;
//
//
//	return 0;
//}
// 宏常被应用于执行简单的运算
//函数 --调用函数 执行运算 函数返回 运算会麻烦
// 此时宏会更简单
// //宏的规模和速度方面更胜一筹
// 宏的类型与参数无关 ，而函数有严格的定义整型，浮点型
// 宏的缺点
// 宏无法调试
// 宏由于类型无关，不够严谨
// 宏容易带来运算优先级的问题，导致程容易出现错

//
//int Max(int x, int y)
//{
//	return x > y ? x : y;
//}
//int main()
//{
//	int m1 = Max(-3, 6);
//
//	int m2 = MAX(-3, 6);
//	printf("%d\n", m1);
//	printf("%d\n", m2);
//
//	return 0;
//}
//宏能做到的事情，函数有可能做不到
//#define Malloc(n,type) (type*)malloc(n*sizeof(type))
//int main()
//{
//	Malloc(4, int);//函数做不到
//
//
//	return 0;
//}
//c++中引入了内联函数 具有函数的特点，又具有宏的特点 //之后这段应该在c上运行
//#和##
//运算符 
//#define Print(n,format)   printf("the value of n is "format"\n",n)//这么写发现n替换不了
//#define Print(n,format)   printf("the value of "#n" is " format "\n",n)
//int main()
//{
//	/*rintf("hello""world\n");
//	printf("helloworld\n");*/
//	//两个双引号 可以合并为一个双引号
//	int a = 1;
//	Print(a, "%d");
//
//
//	///	printf("the value of a is %d\n", a);
//	int b = 20;
//	Print(b, "%d");
//	//printf("the value of b is %d\n", b);
//	float f = 5.6f;
//
//	Print(f, "%f");
//	//printf("the value of f is %f\n", f);
//	//逻辑很像 格式不同 功能极其相似
//	//写成宏
//	return 0;
//}

//int main()
//{
//	printf("hello world");
//
//
//	return 0;
//}

//## 运算符号 
//## 可以把位于两边的符号合成一个符号 记号粘合
// \ 是换行符 定义多行的宏时可以使用

//#define GENERIC_MAX(type)  \
//type type##_max(type a,type b) \
//{ \
//return a>b?a:b; \
//}
//GENERIC_MAX(int);
//GENERIC_MAX(double);
//int main()
//{
//	int ret = int_max(3, 5);
//	double f1 = double_max(3.1, 3.2);
//printf("%d\n",ret);
//printf("%.2lf",f1);
//
//
//	return 0;
//}

// 命名约定
// 宏名的名字全部大写
// 函数名不要全部大写
//offsetof 宏
//#define MAX 100
////undef 移除一个宏定义
//int main()
//{
//#undef MAX;
//
//	return 0;
//}

//命令行定义 在vs不可行 gcc上可行
//#define _DEBUG_
//int main()
//{
//	int arr[10];
//	for (int i = 0; i < 10; i++)
//	{
//		arr[i] = i + 1;
//          #ifdef _DEBUG_;
//		printf("%d", arr[i]);
//          #endif;
//	}
//
//	return 0;
//}
//#define M 10
//#if 0
//int main()
//{
////#if 1
////	printf("hello world");
////#endif
//#if M>10
//	printf("hello world");
//#endif
//
//	return 0;
//}
//
//#endif
////#define M 10
//int main()
//{
//#if M==0
//	;
//#elif M==1
//	;
//#elif M==10
//	;
//#else
//	;
//
//#endif 
//	return 0;
//}

//#ifdef MAX
//#ifdefine(MAX)
//#ifndef
//#ifndefine(MAX)


//头文件的包含
//本地文件包含 用 “” 先去本地文件里寻找 ,再去库文件
//库文件  <>
//int year1(int a)
//{
//	if (a % 400 == 0 || (a % 4 == 0 && a % 100 != 0))
//	{
//		return 1;
//	}
//	return 0;
//}
//
//
//int main()
//{
//	int month1[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
//	int year, month, day;
//	int sum = 0;
//	scanf("%d%d%d", &year, &month, &day);
//	if (year1(year)== 1)
//	{
//		month1[1]++;
//		
//	}
//	if (day<0 || day>month1[month-1])
//	{
//		printf( "data error");
//		return  1;
//	}
//	else
//	{
//		
//		for (int i = 0; i < month-1; i++)
//		{
//			sum += month1[i];
//		}
//		sum += day;
//	}
//	printf("%d", sum);
//	return 0;
//}
//A.fgetc是适用于所有输入流字符输入函数
//B.getchar也是适用于所有流的字符输入函数
//C.fputs是适用于所有输出流的文本行输出函数
//D.fread是适用于文件输入流的二进制输入函数


//getchar只适用于标准流 B错误 
//int main()
//{
//	long num = 0;
//	FILE* fp = NULL;
//	if ((fp = fopen("fname.dat", "r")) == NULL)
//	{
//		printf("Can’t open the file!");
//		exit(0);
//	}
//	while (fgetc(fp) != EOF)
//	{
//		num++;
//	}
//	printf("num=%d\n", num);
//	fclose(fp);
//	return 0;
//}
//A.scanf和printf是针对标准输入、输出流的格式化输入、输出语句
//B.fscanf和fprintf是针对所有输入、输出流的格式化输入、输出语句
//C.sscanf是从字符串中读取格式化的数据
//D.sprintf是把格式化的数据写到输出流中
//D 有问题 写到字符串中D 错误
//
//使用所学文件操作，在当前目录下放一个文件data.txt，写一个程序，将data.txt文件拷贝一份，生成data_copy.txt文件。
//
//基本思路：
//
//打开文件data.txt，读取数据
//打开文件data_copy.txt，写数据
//从data.txt中读取数据存放到data_copy.txt文件中，直到文件结束。
//关闭两个文件

//int main()
//{
//	FILE* pf1 = fopen("add.h", "r");
//	if (pf1 == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	FILE* pf2 = fopen("test.cpp", "w");
//	if (pf2 == NULL)
//	{
//		perror("fopen");
//		fclose(pf1);
//		return 1;
//	}
//	int ch = 0;
//	while ((ch = getc(pf1)) !=EOF)
//	{
//		
//		putc(ch, pf2);
//
//
//	}
//	fclose(pf1);
//	pf1 = NULL;
//	fclose(pf2);
//	pf2 = NULL;
//	return 0;
//}
//int main()
//{
//	int a = 3;
//	int arr[a];
//
//
//	return 0;
//}
//由多个源文件组成的C程序，经过编辑、预处理、编译、链接等阶段会生成最终的可执行程序。下面哪个阶段可以发现被调用的函数未定义？()
// 链接 就是代🐎运行起来
//
//#define INT_PTR int*
//typedef int* int_ptr;
//int main()
//{
//	INT_PTR a, b;
//	int_ptr c, d;
//	int i = 0;
//	a = &i;
//	//b = &i;//b是int类型 
//
//
//	return 0;
//}
//文件中定义的四个变量，哪个变量不是指针类型？()
//设有以下宏定义:

/*#define N 4

#define Y(n) ((N+2)*n)*/ /*这种定义在编程规范中是严格禁止的*/



//：z = 2 * (N + Y(5 + 1)); //后，z的值为（   ）2*(4+(4+2)*5+1)
//#define offsetof(s,m) ((size_t)&(((s*)0)->m))

//#define MY_OFFSETOF(type,member) ((size_t)&(((type*)0)->member))
//typedef struct
//{
//	short a;
//	int b;
//}s1;
//
//int main()
//{
//	//s1* s = (s1*)0;
//	//(size_t)&(s->b);
//      int ret= MY_OFFSETOF(s1, b);
//
//printf("%d", ret);//4 
//	return 0;
//}

//写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换。
//思路 
// 1.先得到这个数字的奇数位
//13 0000 0000 0000 0000 0000 0000 0000 1101
// & 0101 0101 0101 0101 0101 0101 0101 0101

//2.再得到这个数字的偶数位
//& 1010 1010 1010 1010 1010 1010 1010 1010

//3.奇数位左移一位 偶数位右移动一位 进行按位或 |
//
//#define CHANGE(a) ((a & 1431655765)<< 1)|((a & 0xaaaaaaaa)>>1)
//int main()        //  此处用10进制数为什么不是一个结果呢?
//{
//	int a = 13;
//	//int a1 = 13;
//	int ret = CHANGE(a);
//	//int ret1 = CHANGE(a1);
//	printf("%d", ret);
//	//printf("%d\n", ret1);
//
//
//	return 0;
//}
/// 仿qsort函数重写冒泡排序
//int cmp(void* e1, void* e2)   //所选择的比较方法
//{
//	return *((int*)e1) - *((int*)e2);
//}
//void swap(char* p1, char* p2, int width)   //实现数组元素的交换
//{
//	int t = 0;
//	int i = 0;
//	for (i = 0; i < width; i++)
//	{
//		t = *p1;
//		*p1 = *p2;
//		*p2 = t;
//		p1++;
//		p2++;
//	}
//}
//void bubble_sort(void* arr, int sz, int width, int(*cmp)(void* e1, void* e2))
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		//冒泡排序趟数
//		for (j = 0; j < sz - 1 - i; j++)   //每一趟冒泡排序
//		{
//			if (cmp((char*)arr + (j * width), (char*)arr + (j + 1) * width) > 0)
//			{
//				//符合条件进行交换
//				swap((char*)arr + (j * width), (char*)arr + (j + 1) * width, width);
//			}
//		}
//	}
////}
//int cmp(const void* p1, const void* p2)
//{
//	return *(int*)p1 - *(int*)p2;
//}
//void swap(char* p1, char* p2, size_t a)
//{
//	int q = 0;
//	int w = 0;
//	for (; q < a; q++)
//	{
//		w = *p1;
//		*p1 = *p2;
//		*p2 = w;
//		p1++;
//		p2++;
//
//	}
//}
//
//
//void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))
//{
//	for (int i = 0; i < sz - 1; i++)
//	{
//		for (int j = 0; j < sz - i - 1; j++)
//		{
//			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
//			{
//				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
//			}
//		}
//	}
//}
//#include <stdio.h>
//大端字节序下
//int main()
//{
//	//int a = 0x11223344;
//	//// 0x 00 33 22 11
//	//char* pc = (char*)&a;
//	//*pc = 0;
//	unsigned int a = 0x1234;//0x 00 00 12 34
//	unsigned char b = *(unsigned char*)&a;//0x 00 00 12 34 
//	printf("%x\n", b);
//	return 0;
//}
//int main()
//{
//	unsigned char a = 200;
//	unsigned char b = 100;
//	unsigned char c = 0;
//	c = a + b;
//	printf("%d %d", a + b, c);
//	return 0;
//}
//下面代码的结果是（ ）
//
//int main()
//{
//	char a[1000] = { 0 };
//	int i = 0;
//	for (i = 0; i < 1000; i++)
//	{
//		a[i] = -1 - i;
//	}
//	printf("%d", strlen(a));
//	return 0;
//}// -1 -2 .... ..-128 127.....0

//int main()
//{
//	int a;
//	int sum = 0;
//	for (a = 1;a<10; a++)
//	{
//
//		sum = sum + a;
//		
//	}
//	printf("Answer is %d.", sum);
//	return 0;
//}

//制作贪吃蛇


//int main()
//{
//
//	//设置控制台的相关属性
//	system("mode con cols=100 lines=30");
//	system("title 贪吃蛇");
//
//		//system用来执行系统命令
//	system("pause");//暂停
//	
//
//	return 0;
//}
//int main()
//{
//	COORD pos1 = { 0,0 };
//	COORD pos2 = { 20,20 };
//	return 0;
//}

//GetStdHandle 可以从一个特定的标准设备中取得一个句柄,使用这个句柄可以操作设备
//int main()
//{
//	//获得标准输出设备的句柄
//	/*HANDLE houtput = NULL;
//   houtput=GetStdHandle(STD_OUTPUT_HANDLE);*/
//
//
//
//	return 0;
//}

//int main()
//{
//	//获得标准输出设备的句柄
//	HANDLE houtput = NULL;
//   houtput=GetStdHandle(STD_OUTPUT_HANDLE);
//   // 定义一个光标信息的结构体
//   CONSOLE_CURSOR_INFO cursor_info = { 0 };
//   
//   //获取和houtput句柄相关的控制台上的光标信息，存放在cursor__info中
//	GetConsoleCursorInfo(houtput,&cursor_info);
//	
//	//修改光标的占比
//	//cursor_info.dwSize = 100;
//	cursor_info.bVisible = false;
//	// console 控制台  cursor 光标 info信息
//	//设置和houtput句柄相关的控制台上的光标信息
//	SetConsoleCursorInfo(houtput, &cursor_info);
//	
//	system("pause");
//return 0;
//}


//int main()
//{
//	//获得标准输出设备的句柄
//	HANDLE houtput = NULL;
//	houtput = GetStdHandle(STD_OUTPUT_HANDLE);
//
//	 //定位光标的位置
//	COORD pos = { 10,20 };
//	SetConsoleCursorPosition(houtput, pos);
//
//	//printf("hello world");
//	//getchar();
//	//system("pause");
//
//}
//

//void set_position(int x,int y)
//{
//	HANDLE houtput = NULL;
//		houtput = GetStdHandle(STD_OUTPUT_HANDLE);
//	
//		 //定位光标的位置
//		COORD pos = { x,y };
//		SetConsoleCursorPosition(houtput, pos);
//}

//SHORT GetAsyncKeyState(int vKey);

//#define KEY_PRESS(vk) (GetAsyncKeyState(vk)&1)?1:0
//结果是1 表示按过
//结果是0 表示没按过
//int main()
//{
//	short ret = GetAsyncKeyState(0x35);
//
//	
//		if ((ret & 1) == 1)
//		{
//			printf("5被按过");
//		}
//		else
//		{
//			printf("没有被按过");
//		}
//	
//	return 0;
//}
//地图

//char 单字节的字符类型
//wchar_t 宽字符
//int main()
//{
//	char*ret=setlocale(LC_ALL, NULL);
//	printf("%s\n", ret);
//	ret = setlocale(LC_ALL, "");
//	printf("%s\n", ret);
//	return 0;
//}
//int main()
//{
//	//设置本地化
//	setlocale(LC_ALL, "");
//
//	char a = 'a';
//	char b = 'b';
//	printf("%c%c\n", a, b);
//	wchar_t wc1 = L'比';
//	wchar_t wc2 = L'特';
//	wprintf(L"%lc\n", wc1);//打印宽字符
//
//	wprintf(L"%lc\n", wc2);//打印宽字符
//
//
//
//
//
//	return 0;
//}

//int main()
//{
//	/*system("mode con cols=1 lines=1");*/
//	//cols 列 line 行
//
//	return 0;
//}
//class.c 游戏的测试
// snake.c 游戏的实现
//snake.h   游戏函数的声明,类型的声明
//完成的是游戏的逻辑
//#include "snake.h"
//void test()
//{
//	int ch = 0;
//	do
//	{
//		system("cls");
//		// 创建贪吃蛇
//		Snake snake = { 0 };
//		 ch = 0;
//
//		//1.找到蛇的头
//		//方向
//		//速度
//		//食物
//		//食物分数
//		//总分数
//		//贪吃蛇的状态
//
//
//		//基于链表来实现贪吃蛇
//		// 使用链表来维护蛇的身体
//		//初始化游戏
//		GameStart(&snake);
//
//
//		//游戏的运行
//		GameRun(&snake);
//
//
//
//		//结束游戏--善后工作
//		GameEnd(&snake);
//		Set_Pos(20, 15);
//		printf("再来一局吗?(Y/N):");
//		ch = getchar();
//		while(getchar()!='\n');//清理\n
//	} while (ch == 'Y' || ch == 'y');
//	Set_Pos(0, 27);
//}
//int main()
//{
//	//设置适配内地环境
//	setlocale(LC_ALL,"");
//	srand((unsigned int)time(NULL));
//	test();
//
//	return 0;
//	
//}



//学吧

//int main()
//{
//	char ch[100];
//	char ch1[100];
//	scanf("%s %s", ch, ch1);
//	char ch2[10000];
//	char* p1 = ch;
//	char* p2 = ch1;
//	char* p3 = ch2;
//	while (*p1)
//	{
//		*p3 = *p1;
//		p3++;
//		p1++;
//	}
//	while (*p2)
//	{
//		*p3 = *p2;
//		p2++;
//		p3++;
//	}
//	*p3 = '\0';
//	puts(ch2);
//
//
//	return 0;
//}
//int main()
//{
//		char ch[100];
//	char ch1[100];
//	
//	scanf("%s %s", ch, ch1);
//	
//	size_t len = strlen(ch1);
//
//	strncat(ch, ch1, len);
//	printf("%s", ch);
//	return 0;
//}


//int main()
//{
//	char ch1[100];
//	char ch2[100];
//	char ch3[100];
//	scanf("%s%s%s", ch1, ch2,ch3);
//	int ret = strcmp(ch1, ch2);
//	int ret1 = strcmp(ch1, ch3);
//	int ret2 = strcmp(ch2, ch3);
//	if (ret > 0 && ret1 > 0)
//	{
//		printf("%s", ch1);
//	}
//	else if (ret < 0 && ret2>0)
//	{
//		printf("%s", ch2);
//	}
//	else if (ret1 < 0 && ret2 < 0)
//	{
//		printf("%s", ch3);
//	}
//
//
//	return 0;
//}

//求最大公约数
//int main()
//{
//	int a, b;
//	scanf("%d%d", &a, &b);
//	int a1, b1;
//	a1 = a;
//	b1 = b;
//	int c;
//	//
//	while (1)
//	{
//		c = a % b;// b%c
//		if (c == 0)
//		{
//			
//			printf("%d ", b);
//			printf("%d", a1 * b1 / b);
//			break;
//		}
//		a = b;
//		b = c;
//	}
//	// 7 % 5 = 2  5 % 2 = 1  2%1==
//
//	return 0;
//}

//计算1+32+52+72+92+....392 的结果。

//输入（Input）：
//
//无
//
//输出（Output）：
//
//1 + 32 + 52 + 72 + 92 + ....392 的值


//int main()
//{
//	int sum = 0;
//	for (int i = 1; i <= 39; i += 2)
//	{
//		sum += i * i;
//	}
//	printf("%d", sum);
//	return 0;
//}

//找到元音

//int main()
//{
//	char arr[10000];
//	char* pa = arr;
//	//std::cin >> arr;
//	char arr1[10000];
//	char* pa1 = arr1;
//
//	while (*pa)
//	{
//		if (tolower(*pa) == 'a' || tolower(*pa) == 'e' || tolower(*pa) == 'i' || tolower(*pa) == 'o' || tolower(*pa) == 'u')
//		{
//			*pa1 = *pa;
//			pa1++;
//			pa++;
//		}
//		else
//		{
//			pa++;
//		}
//	}
//
//	*pa1 = '\0';
//	return 0;
//}


//打印杨辉三角
//
//int math1(int a)
//{
//	if (a <= 1)
//	{
//		return 1;
//	}
//	else
//	{
//		return a * math1(a - 1);//5*m4 5*4*m3 5*4*3*m2 5*4*3*2*m1 
//	}
//}
//int result(int n,int m)
//{
//	return math1(n) / (math1(m) * math1(n - m));
//}
//int main()
//{
//	int n;
//	scanf("%d", &n);
//	int i = 0;
//	printf("%d", math1(5));
	//int j = 1;
	//while (n)
	//{
	//	
	//	for (int i = 0; i < j; i++)
	//	{
	//		printf("%d ", result(j,i+1));
	//	}
	//	printf("\n");

	//	j++;
	//	n--;
	//}

	//return 0;
//}
//int math1(int a)
//{
//	if (a <= 1)
//	{
//		return 1;
//	}
//	else
//	{
//		return a * math1(a - 1);//5*m4 5*4*m3 5*4*3*m2 5*4*3*2*m1 
//	}
//}
//int result(int n,int m)
//{
//	return math1(n) / (math1(m) * math1(n - m));
//}
//int main()
//{
//	int n;
//		scanf("%d", &n);
//		int i = 0;
//		
//		int j = 1;
//	
//		while (n)
//		{
//			
//
//			for (int i = 0; i < j; i++)
//			{
//				if ((result(j - 1, i) <= 10 && result(j - 1, i + 1) >= 10) || (result(j - 1, i) >= 10 && result(j - 1, i + 1) >= 10))
//				{
//					printf("%d ", result(j - 1, i));
//				}
//				else
//				{
//					printf("%d  ", result(j - 1, i));
//				}
//			}
//			printf("\n");
//
//			j++;
//			n--;
//		}
//
//	return 0;
//}

//题目（Description）：
//
//输入一个大于等于6的正偶数，将其拆分成两个素数（质数）的和，比如12 = 5 + 7, 20 = 3 + 17。
//
//素数（质数）：除了1和本身外没有其他因子的数，比如2、3、5、7、11、13 ...... 一般规定1不是素数。
//
//要求：编写一个求素数的函数。
//
//输入（Input ）：
//
//一个大于等于6的正偶数
//
//输出（Output）：
//
//（1）如果输入的是奇数或小于6的偶数，则输出"Input an even num (>=6)"（首字母大写，单词间一个空格，括号内无空格，没有句号"."）
//
//（2）如果是合法输入（一个大于等于6的正偶数），则输出两个素数且满足它们的和是输入的偶数
//
//要求：小素数在前，大素数在后；且是所有可能拆分中，有最小素数的那一组。
//
//比如：20 = 3 + 17 且 20 = 7 + 13，则输出3 + 17（中间没有空格），因为这一组有满足条件的最小素数
//
//提示（Hint）：
//
//分别编写 prime 和 main 函数，用 prime 函数实现素数判断。
//
//int prime(int y)
//{
//	if (y是素数)  return 1;
//	else  return 0;
//}
//
//示例1（Sample）：
//
//输入（Input）：
//
//20
//
//输出（Output）：
//
//3 + 17
//
//示例2（Sample）：
//
//输入（Input）：
//
//33
//
//输出（Output）：
//
//Input an even num(>= 6)

//int prime(int a)
//{
//	for (int i = 2; i < a; i++)
//	{
//		if (a % i == 0)
//		{
//			return 0;
//		}
//	}
//	return 1;
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	if (n % 2== 1)
//	{
//		printf("Input an even num(>= 6)");
//		return ;
//	}
//	else
//	{
//		if (n <= 6)
//		{
//			printf("Input an even num(>= 6)");
//			return;
//		}
//		for (int i = 2; i < n; i++)
//		{
//			if (prime(i) == 1 && prime(n - i) == 1)
//			{
//				printf("%d + %d", i, n - i);
//				return ;
//					
//			}
//		}
//	}
//
//	return 0;
//}
//StudybarCommentBegin

//int f (int x)
//{
//	if (x == 1 || x == 2)
//	{
//		return 1;
//
//	}
//	else
//	{
//		return f(x - 1) + f(x - 2);
//	}
//}
//
//
//int main()
//{
//	int f(int x);
//	int n;
//	scanf("%d", &n);
//	printf("%d\n", f(n));
//	return 0;
//}

//
//输入一个正数x和一个正整数n，求下列算式的值。
//
//x - x2 / 2!+ x3 / 3!+ ... + (-1)n - 1xn / n!
//
//要求编写三个函数：
//
//（1）fact(n)计算n的阶乘；
//
//（2）mypow(x, n)计算x的n次幂（即xn）；
//
//（3）equation(x, n)计算题目给出的算式。
//
//三个函数的返回值类型是double。
//
//输入（Input）：
//
//x n
//
//输出（Output）：
//
//数列和（保留4位小数）
//
//提示（Hint）：
//
//程序的前缀代码已经给出。
//
//示例（Sample）：
//
//输入（Input）：
//
//2.0 3
//
//输出（Output）：
//
//1.3333

//StudybarCommentBegin
//double fact(int n)
//{
//	if (n <= 1)
//	{
//		return 1.0;
//	}
//	else
//	{
//		return 1.0*n * fact(n - 1);
//	}
//}
//double mypow(int x, int n)
//{
//	return pow(x, n);
//}
//double equation(double x, int n)
//{
//	
//	//x - x2 / 2!+ x3 / 3!+ ... + (-1)n - 1xn / n!
//	double sum = 0;
//	for (int i = 1; i <= n; i++)
//	{
//		sum +=mypow(-1,i+1)* mypow(x, i) / fact(i);
//		
//	}
//	return sum;
//}
//int main()
//{
//	
//	double equation(double x, int n);
//	int n;
//	double x;
//	scanf("%lf%d", &x, &n);
//	printf("%.4f\n", equation(x, n));
//	return 0;
//}
//
//double fact(int n)
//{
//	double sum = 1;
//	for (int i = 1; i <= n; i++)
//	{
//		sum = sum * i;
//	}
//	return sum;
//}
//double equation(double x, int n)
//{
//	double sum = 0;
//	for (int i = 1; i <= n; i++)
//	{
//		sum = sum + (pow(-1, i - 1) * pow(x, i) / fact(i));
//	}
//	return sum;
//}

//double mul(int n)
//{
//	double count = 0;
//	for (int i = 1; i <= n; i++)
//	{
//
//		int sum = 1;
//		for (int j = 1; j <= i; j++)
//		{
//			sum *= j;
//		}
//		count += 1 / (double)sum;
//	}
//	return count;
//}
//
//
//int main()
//{
//	double mul(int n);
//	int n;
//	scanf("%d", &n);
//	printf("%.2f\n", mul(n));
//	return 0;
//}
//int int_cmp(const void* p1, const void* p2)
//{
//	return *(int*)p1 - *(int*)p2;
//}
//
//void order(int x[])
//{
//	
//	qsort(x, 10, sizeof(x[0]), int_cmp);
//
//}
//int main()
//{
//	void order(int x[]);
//	int x[10],i;
//	for(i=0;i<=9;i++)  scanf("%d",&x[i]);
//	order(x);
//	for(i=0;i<=9;i++)  printf("%d ",x[i]);
//}
//int max(int x[])
//{
//
//}
//int main()
//{
//	int max(int x[]);
//	int x[8], i;
//	for (i = 0; i <= 7; i++)  scanf("%d", &x[i]);
//	printf("%d\n", max(x));
//	return 0;
//}
//
//int main()
//{
//	int arr[10];
//	int sum = 0;
//	int count = 0;
//	for (int i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	for (int j = 0; j < 10; j++)
//	{
//		sum += arr[j];
//	}
//	sum /= 10;
//	for (int d = 0; d < 10; d++)
//	{
//		if (arr[d] > sum )
//		{
//			count++;
//		}
//	}
//	printf("%d\n", count);
//	printf("%d", sum );
//	return 0;
//}
//void swap(int* p1, int* p2)
//{
//	if (*p1 < *p2)
//	{
//		int tmp = *p1;
//		*p1 = *p2;
//		*p2 = tmp;
//	}
//}
//void exchange(int* a, int* b, int* c)
//{
//	swap(a, b);
//	swap(a, c);
//	swap(b, c);
//}
//
//int main()
//{
//	void exchange(int* a, int* b, int* c);
//	int x, y, z;
//	int* a = &x, * b = &y, * c = &z;
//	scanf("%d%d%d", a, b, c);
//	exchange(a, b, c);
//	printf("%d %d %d\n", x, y, z);//a最大 b其次 c最小
//
//	return 0;
//}

//void Print(int* p1)
//{
//	for (int j = 0; j < 10; j++)
//	{
//		printf("%d ", *p1);
//		p1++;
//
//	}
//}
//
//
//int main()
//{
//	int arr[10];
//	for (int i = 0; i < 10; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	Print(arr);
//	return 0;
//}

//void in_num(int* x)
//{
//	for (int i = 0; i < 10; i++)
//	{
//		scanf("%d", &x[i]);//x[i]=*(x+i)
//	}
//}
//void exchange(int* x)
//{
//	//最大和最后一个 最小和第一个
//	int min = x[0];
//	int max = x[0];
//	for (int d = 0; d < 10; d++)
//	{
//		if (min > x[d])
//		{
//			min = x[d];
//		}
//		if (max < x[d])
//		{
//			max = x[d];
//		}
//	}
//	for (int c = 0; c < 10; c++)
//	{
//		if(x[c] == min)
//		{ 
//			int tmp = x[0];
//			x[0] = x[c];
//			x[c] = tmp;
//
//		}
//		if (x[c] == max)
//		{
//			int q = x[9];
//			x[9] = x[c];
//			x[c] = q;
//		}
//	}
//}
//void out_num(int* x)
//{
//	for (int j = 0; j < 10; j++)
//	{
//		printf("%d ", x[j]);
//	}
//}
//int main()
//{
//	void in_num(int* x);
//	void exchange(int* x);
//	void out_num(int* x);
//	int x[10];
//	in_num(x);
//	exchange(x);
//	out_num(x);
//	return 0;
//}
//void swapStrings(char* a, char* b) 
//{
//	int lena = strlen(a);
//	int lenb = strlen(b);
//	//abc //abcd
//	if (lena < lenb)
//	{
//		
//		a[lenb] = '\0';
//		char tmp[100];
//		strcpy(tmp, a);
//		strcpy(a, b);
//		strcpy(b, tmp);
//	}
//	else
//	{
//		b[lena] = '\0';
//		char tmp1[1000];
//		strcpy(tmp1, a);
//		strcpy(a, b);
//		strcpy(b, tmp1);
//	}
//
//
//}
//int main() {
//	char str1[100] = "Hello";
//	char str2[100] = "World";
//	printf("Before swap: str1 = %s, str2 = %s\n", str1, str2);
//	swapStrings(str1, str2);
//	printf("After swap: str1 = %s, str2 = %s\n", str1, str2);
//	return 0;
//}
//void swapStrings(char* a, char* b)//abc aenf
//{
//	char tmp[1000];
//	strcpy(tmp, a);
//	strcpy(a, b);//strcpy会将\0复制过去,不用考虑越界的问题,前面打的有问题,这么打是正解
//
//	strcpy(b, tmp);
//
//
//
//}
//int main() {
//	char str1[100] = "Hello";
//	char str2[100] = "World";
//	printf("Before swap: str1 = %s, str2 = %s\n", str1, str2);
//	swapStrings(str1, str2);
//	printf("After swap: str1 = %s, str2 = %s\n", str1, str2);
//	return 0;
//}
//
//void swap(char* a, char* b)
//{
//	char tmp[1000];
//	strcpy(tmp, a);
//	strcpy(a, b);
//	strcpy(b, tmp);
//
//
//
//}
//int main()
//{
//	char a[100];
//	char b[100];
//	char c[100];
//	gets(a);
//	gets(b);
//	gets(c);
//	if (strcmp(a, b) > 0)
//	{
//		swap(a, b);
//	}
//	if (strcmp(a, c) > 0)
//	{
//		swap(a, c);
//	}
//	if (strcmp(b, c) > 0)
//	{
//		swap(b, c);
//	}
//	printf("%s\n%s\n%s", a, b, c);
//	return 0;
//}

//int main()
//{
//	float sum = 0;
//	int i = 1;
//	while (i<=10000)//i>=10^4
//	{
//		sum += 1.0 / i * (int)pow(-1, i - 1);
//		i++;
//	}
//
//	printf("%.6f\n", sum);
//	return 0;
//}
//int main()
//{
//
//	int i;
//	float sum, sign;
//	i = 1;
//	sum = 0;
//	sign = 1.0;
//	while ((1.0 / i) >= 1e-4)
//	{
//
//		sum += sign / i;
//		i++;
//		sign = -sign;
//	}
//	printf("%.6f", sum);
//}
//hello world
//倒置字符串
//i like beijing.
//bejing. like i
//思路 先逆序整个字符串，再逆序每个单词
//void reverse(char* left, char* right)
//{
//	while (left < right)
//	{
//		char tmp = *left;
//		*left = *right;
//		*right = tmp;
//		left++;
//		right--;
//}
//}
//int main()
//{
//	char arr[100];
//	gets(arr);
//	int len = strlen(arr);
//	reverse(arr, arr + len - 1);
//	//开始逆序单词
//	char* cur = arr;
//	
//	while(*cur)		
//	{
//		char* start = cur;
//		while (*cur != ' '&&*cur!='\0')
//		{
//			cur++;
//		}
//		reverse(start, cur - 1);
//		if(*cur!='\0')
//		{
//			cur++;
//		}
//	}
//	puts(arr);
//	return 0;
//}
//
//int main()
//{
//	//先倒着加，
//	//再倒着打印
//	int a = 0;
//	scanf("%d", &a);
//	char arr[14];
//	int i = 0;
//	int j = 0;
//	while (a)
//	{
//		if (j != 0 && j % 3 == 0)
//		{
//			arr[i] = ',';
//			i++;
//			
//		}
//		arr[i]=a % 10+'0';
//		i++;
//		j++;
//		a /= 10;
//	}
//	for (int x = i - 1; x >= 0; x--)
//	{
//		printf("%c", arr[x]);
//	}
//	//499 255 311 
//	//113,255,
//	return 0;
//}
//strchr 在字符串中寻找字符 没有返回NULL






//数据结构初阶
//数据结构初阶
//数据结构初阶
//数据结构初阶
//数据结构初阶
//数据结构初阶
//数据结构初阶
//数据结构初阶
// 数据结构学完刷剑指offer  c++初阶结束后学完刷leetcode 分类刷   
// 
//10.4第一节课  时间复杂度 空间复杂度
//1.算法效率 
// 时间效率 空间效率 
//算法中基本操作的执行次数，称之为时间复杂度
//大O的渐进表示法
//func的时间的复杂度O(n^2)
//void FUnc(int N)
//{
//	int count = 0;
//	for (int k = 0; k < 2 * N; k++)
//	{
//		++count;
//	}
//	int M = 10;
//	while (M--)
//	{
//		++count;
//	}
//	printf("%d\n", count);
//}
//O(n) = 2n + 10; O(N)
//O(100N)确定的常数都不要
// 只保留最高阶项 
//O(M+N) O(100)->O(1)不是代表一次 代表常数次
//
//常数1取代运行时间中所有的加法常数
//

//const char* strchr(const char* str, int character);
//时间复杂度？
//abcdefgihi
//最好 最坏 平均 
// 1次  n次  n/2
//一般关注的是最坏的情况 所以是O(N)
//冒泡排序 
//最好: O(N) 
//
//最坏  O(N^2)


//二分查找  最好 O(1)

//最坏 log 2 N;
//区间缩放到一个值时 要么找到要么找不到
//查找多少次就除多少个2 
//N/2/2/2..../2=1
// 2^x==N
//x=O(log 2 N); 牛逼 不实用 需要有序
//红黑树 log 2 N 之后会学
//不好写 所以我们可以把这个对数简化位logN
//时间复杂度里 只有以2为底的才可以简化
//有些地方也会简写为lgN,不推荐 会搞混


//a数组有序



//n的阶乘
//多少次
//O(N) n个O(1)相加 O(N)
//Fac(N)-> Fac(N-1)



//斐波那契数列
//?
//O(2^N)   等比数列-一些常数(缺失的 常数)
// 没有用的算法 时间复杂度太高
//
//int count = 0;
//int fib(size_t N)
//{
//	count++;
//	if (N < 3)
//	{
//		
//		return 1;
//	}
//	else
//	{
//	
//		return fib(N - 1) + fib(N - 2);
//	}
//}
//int main()
//
//{
//	fib(10);
//	printf("%d", count);
//	
//	return 0;
//}
//
//
//数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺
//失的整数。你有办法在O(n)时间内完成吗

//1.排序加二分查找
//O(N*logN)

//2.异或 利用n^n=0;n^0=n;
//[3,0,1]
//[0,1,2,3]
//O(N)



//int missingNumber(int* nums, int numsSize)
//{
//	int val=0;
//	for (int i = 0; i < numsSize; i++)
//	{
//		val ^= nums[i];
//	}
//	for (int i = 0; i < numsSize+1; i++)
//	{
//		val ^= i;
//	}
//	
//	return val;
//}
//int main()
//{
//	int arr[3] = { 0,1,2 };
//	int ret=missingNumber(arr, 3);
//	printf("%d", ret);
//
//	return 0;
//}
//

//3.公式计算
//0-N求和 -数组
////公式和时间复杂度没关系 O(N
// )



//给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
//O(k*N)
//最坏情况下 O(N^N)
// 
//45678

//void rotate(int* nums, int numsSize, int k)
//{
//	k = k & numsSize;
//	
//	for (int i = k; i <= k + numsSize; i++)
//	{
//		printf("%d ", nums[i]);
//	}
//}
//
//int main()
//{
//	int arr[8] = { 1,2,3,4,5,6,7,8 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	rotate(arr, sz, 3);
//
//	return 0;
//}

//
//void rotate(int* nums, int numsSize, int k) {
//	int newArr[numsSize];
//	for (int i = 0; i < numsSize; ++i) 
//	{
//		newArr[(i + k) % numsSize] = nums[i];
//	}// k=3;
//	for (int i = 0; i < numsSize; ++i) 
//	{
//		nums[i] = newArr[i];
//	}
//}       //1 2 3 4 5 6 7 8     6 7 8 1 2 3 4 5 
//下标    0 1 2 3 4 5 6 7     0 1 2 3 4 5 6 7


//
//void swap(int* a, int* b) 
//{
//	int t = *a;
//
//	*a = *b, * b = t;
//}
//
//void reverse(int* nums, int start, int end)
//{
//	while (start < end) {
//		swap(&nums[start], &nums[end]);
//		start++;
//		end++;
//	}
//}
//
//void rotate(int* nums, int numsSize, int k) 
//{
//	k %= numsSize;
//	reverse(nums, 0, numsSize - 1);
//	reverse(nums, 0, k - 1);
//	reverse(nums, k, numsSize - 1);
//}
//原始数组	1 2 3 4 5 6 7 ///5 6 7 1 2 3 4
//翻转所有元素	7 6 5 4 3 2 1
//翻转[0, kmodn−1] 区间的元素	5 6 7 4 3 2 1
//翻转[kmodn, n−1] 区间的元素	5 6 7 1 2 3 4

//以空间换时间 

//void rotate(int* nums, int numsSize, int k)
//{
//	k = k % numsSize;
//	int* p = (int*)malloc(sizeof(int) * numsSize);
//	memcpy(p, nums + numsSize - k, sizeof(int) * k);
//	memcpy(p + k, nums, sizeof(int)*(numsSize - k));
//	memcpy(nums, p, sizeof(int)*(numsSize));
// free(p);
// p=NULL:
//}
//
//int main()
//{
//	int arr[8] = { 1,2,3,4,5,6,7,8 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	rotate(arr, sz, 3);
//	
//	return 0;
//}




//空间复杂度
//空间复杂度计算的是变量的个数
//主要通过函数在运行时候显式申请的额外空间来确定
// 额外
//冒泡排序的空间复杂度
//O(1)
//返回斐波那契数列的前n项
//O(N)



//递归阶乘的空间复杂度
//O(N) N个O(1)

//
//void F1()
//{
//
//	int a = 1;
//	printf("%p", &a);
//
//}
//void F2()
//{
//	int b = 0;
//	printf("%p", &b);
//	F2();
//}
//int main()
//{
//	//F1();
//	F2();//用同一处地址
//
//
//	return 0;
//}

//斐波那契数列数列的空间复杂度
//O(N)
//时间一去不复返,不可重复利用
//空间用了之后归还,可以重复利用

//IO型 scanf输入 printf输出 写完整的程序
// 
// 接口型 输入条件-参数 结构 返回值返回 写一个函数 部分程序
// 
//


//  10.5 顺序表 链表
//1.线性表 
//2.顺序表 
//3.链表 
//4.顺序表和链表的区别和联系
// 
// 

//静态顺序表
//typedef int SLDATATYPE;//类型名称
//#define N 10

//struct Seqlist//顺序,序列 英文 sequence
//{
//	SLDATATYPE a[N];
//	SLDATATYPE size;
//
//
//};//开多了浪费 ,开少了不够用 

//动态顺序表 按需申请

//增删查改
//#include "snake.h"
//SL s1;
//void ClassSeqList()
//{
//	//SL s1;//这里会报错 vs比较严格 不允许使用没初始化的局部变量,可以使用全局变量
//	//SL* s2 = NULL;
//	SeqInit(&s1);
//	//SeqDestroy(&s1);
//	/*SeqPushback(&s1, 1);
//	SeqPushback(&s1, 2);
//	SeqPushback(&s1, 3);
//	SeqPushback(&s1, 4);
//	SeqPushback(&s1, 5);
//	SeqPushback(&s1, 6);
//	SeqPushback(&s1, 7);*/
//	//SLPopBack(&s1);
//	//// 
//	SeqPushFront(&s1, 1);
//	SeqPushFront(&s1, 2);
//	SeqPushFront(&s1, 3);
//	SeqPushFront(&s1, 4);
//	//SLPopFront(&s1);
////	SLPopFront(&s1);
//	//SLPopFront(&s1);
//	//SLInsert(&s1, 3, 5);
//	SeqPrint(&s1);
//	//头删/头插N个数据时间复杂度：O(N^2)
//    //这里尽量避免用头插
//	//尾删/尾插N个数据时间复杂度=O(N)
//}
//void menu()
//{
//	printf("******************\n");
//	printf("******************\n");
//	printf("****1.尾插2.尾删**\n");
//	printf("****3.****4.******\n");
//	printf("****0.************\n");
//	printf("******************\n");
//
//}
//int main()
//{
//	int x = 0;
//	ClassSeqList();
//	//ClassSeqList();
////	int option;
////again:
////	menu();
////	scanf("%d", &option);
////	switch (option)
////	{
////	case 1:
////		while (x != -1)
////		{
////			scanf("%d", &x);
////			SeqPushback(&s1, x);
////		}
////		break;
////	case 2:
////		break;
////	case 3:
////		SeqPrint(&s1);
////		break;
////	case 0:
////		break;
////	default:
////		break;
////
////	}
////	goto again;
//
//	return 0;
//}
//给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
//
//假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
//
//更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
//返回 k
//1 2 3 4 5 4 1 4 4 4 2 5

///时间复杂度是O(N)
//空间复杂度是O(1)
//int removeElement(int* nums, int numsSize, int val)
//{
//	 //src
//     //0 1 2 2 3 0 4 2
//	 //dst
//	int src = 0;
//	int dst = 0;
//	while (src < numsSize)
//	{
//		if (nums[src] != val)
//		{
//			nums[dst] = nums[src];
//			src++;
//			dst++;
//
//		}
//		else
//		{
//			src++;
//		}
//	}
//	return dst;
//}
//[3, 2, 2, 3]
//val =
//3
//输出
//[2, 2, 2]
//预期结果
//[2, 2]
//int main()
//{
//
//	int nums[10] = { 0, 1 ,2 ,2, 3, 0, 4, 2 ,1,2};
//	int ret=removeElement(nums, 10, 2);
//	printf("%d\n", ret);
//	
//	return 0;
//}

//dst
// 




//给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

//考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

//
// 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。

//1 1 12 222 33 44

//空间复杂度 O(1) 时间复杂度 O(N)
//int removeDuplicates(int* nums, int numsSize) 
//{
//	int dst = 0;
//	int src = 1;
//
//	while (src < numsSize)
//	{
//		
//		if (nums[src] != nums[dst])
//		{
//
//			dst++;                                                                                                                                                                       
//			nums[dst] = nums[src];
//			src++;
//		}
//		
//		else
//		{
//			src++;
//  		}
//	}
//	return dst+1;

//简化
// int removeDuplicates(int* nums, int numsSize) 
//{
//	int dst = 0;
//	int src = 1;
//
//	while (src < numsSize)
//	{
//
//		if (nums[src] != nums[dst])
//			nums[++dst] = nums[src++];
//		  src++;
//
//	}
//	return dst + 1;
//}
//nums =
//[1, 1, 2][1 ,1,2]
//输出
//[1]
//预期结果
//[1, 2]

/*
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n */
//
//输入：nums1 = [1, 1, 1, 0, 0, 0], m = 3, nums2 = [2, 5, 6], n = 3
//输出：[1, 2, 2, 3, 5, 6]
//解释：需要合并[1, 2, 3] 和[2, 5, 6] 。
//合并结果是[1, 2, 2, 3, 5, 6] ，其中斜体加粗标注的为 nums1 中的元素
/*void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) 
{
	int s1 = 0;
	int s2 = 0;
	int s3 = 0;
	int nums[n + m];
	
	while (s1<=m||s2<=n)
	{
		if (s1 == m)
		{
			nums[s3++] = nums2[s2++];
		}
		if (s2 == n)
		{
			nums[s3++] = nums1[s1++];
		}
		if (nums1[s1] < nums2[s2]&&s1 < m)
		{
			nums[s3] = nums1[s1];
			s3++;
			s1++;
		}
		else if (nums1[s1] = nums2[s2])
		{
			nums[s3] = nums1[s1];
			s3++;
			nums[s3] = nums1[s1];
			s3++;
			s1++;
			s2++;
		
		}
		else if(nums1[s1]>nums2[s2]&&s2<n)
		{
			nums[s3] = nums2[s2];
			s3++;
			s2++;
		}
	}
	memcpy(nums1, nums,sizeof(int)*(n+m));

}*/  //有问题 error 从前往后比小的不如从后往前比大的
//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
//{
//	int end1 = m - 1;
//	int end2 = n - 1;
//	int dst = m + n - 1;
//	while (end1 >= 0 && end2 >= 0)
//	{
//		if (nums1[end1] > nums2[end2])
//		{
//			nums1[dst--] = nums1[end1];
//			
//		}
//		else
//		{
//			nums1[dst] = nums1[end2];
//			end2--;
//			dst--;
//		}
//	} 
//	while (end2 >= 0)
//	{
//		nums1[dst--] = nums2[end2--];
//	}
//
//
//	//顺序表缺点
//	//中间头部插入删除数据,需要挪动数据,效率低下
//	//空间不够,扩容.扩容有一定的消耗,其次还有可能会有一定空间浪费
//
//}
//
// void fun(int n) {
//	int i = l;
//	while (i <= n)
//		i = i * 2;
//}
 //时间复杂度 O(logN)1 2 4 8 类似于二分查找 逼近于n

//
//int** fun(int n) 
//{
//	int* *s = (int**)malloc(n * sizeof(int*));
//	while (n--)
//		s[n] = (int*)malloc(n * sizeof(int));
//	return s;
//}//二维数组

//int removeDuplicates(int* nums, int numsSize)
//{
//	int dst = 0;
//	int src = 1;
//	while (src<=numsSize)
//	{
//		if (nums[src] != nums[dst])
//		{
//			dst++;
//			nums[dst] = nums[src];
//			src++;
//	}
//		else
//		{
//			src++;
//		}
//	}
//	return dst + 1;
//}

//void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
//{
//	int end1 = m - 1;
//	int end2 = n - 1;
//	int dst = m + n - 1;
//
//	while (end1 >= 0 && end2 >= 0)
//	{
//		if (nums1[end1] > nums2[end2])
//		{
//			nums1[dst] = nums1[end1];
//			dst--;
//			end1--;
//		}
//		else
//		{
//			nums1[dst] = nums2[end2];
//			dst--;
//			end2--;
//		}
//
//	}
//	while(end2>=0)
//		{ 
//		nums1[dst] = nums2[end2];
//		dst--;
//		end2--;
//
//	}
//}
//#include "snake.h"
//void class()
//{
//	SLTNode * plist = NULL;
//	SLPushBack(&plist, 1);
//	SLPushBack(&plist, 2);
//	SLPushBack(&plist, 3);
//	SLPushBack(&plist, 4);
//	
//
//	
//	SLTNode* ret = SListFind(plist,2);
//	SListErase(&plist, ret);
//	Print(plist);
//	//NULL ?
//	//形参的改变不影响实参
//
//}
//void Func(int** ptr)
//{
//	ptr = (int*)malloc(sizeof(int));
//}

//int main()
//{
//	class();
//	/*int* px = NULL;
//	Func(px);*/
//	return 0;
//}








///10.9 队列
//只允许一端插入，另一端删除数据
//先进先出
//从队尾入，从队头出

//#include "snake.h"
////queue 队列
//void Class()
//{
//	Que Q;
//	QInit(&Q);
//	QPush(&Q, 1);
//	QPush(&Q, 2);
//	QPush(&Q, 3);
//	QPush(&Q, 4);
//	QPush(&Q, 5);
//	while(!QEmpty(&Q))
//	{
//		printf("%d ", QFront(&Q));
//		QPop(&Q);
//	}
//	QDestroy(&Q);
//}
//int main()
//{
//	Class();
//	return 0;
//}


//
//请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
//
//实现 MyStack 类：
//
//void push(int x) 将元素 x 压入栈顶。
//int pop() 移除并返回栈顶元素。
//int top() 返回栈顶元素。
//boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
// 

 
//
//typedef  int  QDATATYPE;
//typedef struct QueueNode
//{
//	struct QueueNode* next;
//	QDATATYPE data;
//}QNode;
//
//typedef struct Queue
//{
//	QNode* head;
//	QNode* tail;
//	int size;
//}Que;
//
//
//void QInit(Que* pq)
//{
//	assert(pq);
//
//	pq->head = pq->tail = NULL;
//	pq->size = 0;
//
//
//}
//
//void QDestroy(Que* pq)
//{
//	assert(pq);
//	QNode* cur = pq->head;
//	while (cur)
//	{
//		QNode* next = cur->next;
//		free(cur);
//		cur = next;
//	}
//	pq->head = pq->tail = NULL;
//	pq->size = 0;
//}
//
//void QPush(Que* pq, QDATATYPE x)
//{
//	assert(pq);
//	QNode* newnode = (QNode*)malloc(sizeof(QNode));
//	newnode->data = x;
//	newnode->next = NULL;
//	if (newnode == NULL)
//	{
//		perror("malloc");
//		return;
//	}
//	//判断一下是否为空，因为没有哨兵位的头节点 
//	if (pq->tail == NULL)
//	{
//		assert(pq->head == NULL);
//		pq->head = pq->tail = newnode;
//	}
//	else
//
//	{
//		pq->tail->next = newnode;
//
//		pq->tail = newnode;
//	}
//	pq->size++;
//}
////队只能队尾进队头出
//void QPop(Que* pq)
//{
//	assert(pq);
//	assert(pq->head);
//
//	// 考虑如果head==tail==NULL。
//
//	if (pq->head->next == NULL)
//	{
//		free(pq->head);
//		pq->head = pq->tail = NULL;
//	}
//	else
//	{
//
//		QNode* cur = pq->head->next;
//		free(pq->head);
//		pq->head = cur;
//	}
//
//
//	pq->size--;
//}
//
//QDATATYPE QSize(Que* pq)
//{
//	assert(pq);
//
//	return pq->size;
//}
//
//bool QEmpty(Que* pq)
//{
//	assert(pq);
//
//	return pq->size == 0;
//}
//
//QDATATYPE QFront(Que* pq)
//{
//	assert(pq);
//	assert(!QEmpty(pq));
//	return pq->head->data;
//}
//
//QDATATYPE QBack(Que* pq)
//{
//	assert(pq);
//	assert(!QEmpty(pq));
//	return pq->tail->data;
//}
//
//
//
//
//
//typedef struct
//{
//	Que q1;
//	Que q2;
//} MyStack;
//
//
//MyStack* myStackCreate()
//{
//	MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
//	if (pst == NULL)
//	{
//		perror("malloc");
//		return NULL;
//	}
//	QInit(&pst->q1);
//	QInit(&pst->q2);
//
//	return pst;
//}
//
//void myStackPush(MyStack* obj, int x)
//{
//	if (!QEmpty(&obj->q1))
//	{
//		QPush(&obj->q1, x);
//
//	}
//	else
//	{
//		QPush(&obj->q2, x);
//	}
//
//}
//
//int myStackPop(MyStack* obj)
//{
//	Que* emptyobj = &obj->q1;
//	Que* noemptyobj = &obj->q2;
//	if (QEmpty(noemptyobj))
//	{
//		emptyobj = &obj->q2;
//		noemptyobj = &obj->q1;
//	}
//	while (QSize(noemptyobj) > 1)
//	{
//		QPush(emptyobj, QFront(noemptyobj));
//		QPop(noemptyobj);
//	}
//	int pop = QFront(noemptyobj);
//
//	QPop(noemptyobj);
//	return pop;
//
//
//}
//
//int myStackTop(MyStack* obj)
//{
//	if (!QEmpty(&obj->q1))
//	{
//		return QBack(&obj->q1);
//	}
//	else
//	{
//		return QBack(&obj->q2);
//	}
//}
//
//bool myStackEmpty(MyStack* obj)
//{
//	return QEmpty(&obj->q1) && QEmpty(&obj->q2);
//}
//
//void myStackFree(MyStack* obj)
//{
//	QDestroy(&obj->q1);
//	QDestroy(&obj->q2);
//}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);

 * int param_2 = myStackPop(obj);

 * int param_3 = myStackTop(obj);

 * bool param_4 = myStackEmpty(obj);

 * myStackFree(obj);
*/


//
//typedef struct
//{
//	int* a;
//	int capacity;
//	int top;
//
//} MyStack;
//
//
//MyStack* myStackCreate()
//{
//	MyStack * Stack;
//	Stack->a = (int*)malloc(sizeof(int) * 4);
//	Stack->top = 0;
//	Stack->capacity = 4;
//
//}
//
//void myStackPush(MyStack* obj, int x) {
//
//}
//
//int myStackPop(MyStack* obj) {
//
//}
//
//int myStackTop(MyStack* obj) {
//
//}
//
//bool myStackEmpty(MyStack* obj) {
//
//}
//
//void myStackFree(MyStack* obj) {
//
//}

//  一个只出栈  若没 有元素，则将入栈的元素拿过来 有则出 4 3 2 1
//
//typedef int STDATATYPE;
//typedef struct Stack
//{
//	int top;
//	int capacity;
//	int* a;
//}ST;
//
//typedef struct
//{
//	ST Stack1;
//	ST Stack2;
//} MyQueue;
//
//void STInit(ST* ps);
//void STPush(ST* ps, STDATATYPE x);
//void STDestroy(ST* ps);
//void STPop(ST* ps);
//int STSize(ST* ps);
//bool STEmpty(ST* ps);
//int STTop(ST* ps);
//
//void STInit(ST* ps)
//{
//	assert(ps);
//	ps->a = (STDATATYPE*)malloc(sizeof(STDATATYPE) * 4);
//
//	ps->capacity = 4;
//	ps->top = 0;
//
//
//}
//
//
//void STPush(ST* ps, STDATATYPE x)
//{
//	assert(ps);
//	if (ps->capacity = ps->top)
//	{
//		STDATATYPE* tmp = (STDATATYPE*)realloc(ps->a, sizeof(STDATATYPE) * ps->capacity * 2);
//		if (tmp == NULL)
//		{
//			perror("realloc");
//			return;
//		}
//		ps->a = tmp;
//		ps->capacity *= 2;
//
//
//	}
//	ps->a[ps->top] = x;
//	ps->top++;
//}
//
//void STPop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	ps->top--;
//
//}
//int STSize(ST* ps)
//{
//	assert(ps);
//
//	return ps->top;
//}
//bool STEmpty(ST* ps)
//{
//
//	assert(ps);
//	return ps->top == 0;
//
//}
//int STTop(ST* ps)
//{
//	assert(ps);
//	assert(!STEmpty(ps));
//	return ps->a[ps->top - 1];
//}
//void STDestroy(ST* ps)
//{
//	assert(ps);
//	free(ps->a);
//	ps->a = NULL;
//	ps->capacity = 0;
//	ps->top = 0;
//}
//
//
//
//
//
//MyQueue* myQueueCreate()
//{
//	MyQueue* pst = (MyQueue*)malloc(sizeof(MyQueue));
//	STInit(&pst->Stack1);
//	STInit(&pst->Stack2);
//	return pst;
//
//
//}
//
//void myQueuePush(MyQueue* obj, int x)
//{
//	STPush(&obj->Stack1, x);
//}
//
//int myQueuePop(MyQueue* obj)
//{
//	if (STEmpty(&obj->Stack2))
//	{
//		while (!STEmpty(&obj->Stack1))
//		{
//			STPush(&obj->Stack2, STTop(&obj->Stack1));
//			STPop(&obj->Stack1);
//		}
//	}
//	int front = STTop(&obj->Stack2);
//	STPop(&obj->Stack2);
//	return front;
//}
//
//int myQueuePeek(MyQueue* obj)
//{
//	if (STEmpty(&obj->Stack2))
//	{
//		while (!STEmpty(&obj->Stack1))
//		{
//			STPush(&obj->Stack2, STTop(&obj->Stack1));
//			STPop(&obj->Stack1);
//		}
//	}
//	int front = STTop(&obj->Stack2);
//
//	return front;
//}
//
//bool myQueueEmpty(MyQueue* obj)
//{
//	return STEmpty(&obj->Stack1) && STEmpty(&obj->Stack2);
//}
//
//void myQueueFree(MyQueue* obj)
//{
//	STDestroy(&obj->Stack2);
//	STDestroy(&obj->Stack1);
//	free(obj);
//	obj = NULL;
//}
//
/////**
// * Your MyQueue struct will be instantiated and called as such:
// * MyQueue* obj = myQueueCreate();
// * myQueuePush(obj, x);
//
// * int param_2 = myQueuePop(obj);
//
// * int param_3 = myQueuePeek(obj);
//
// * bool param_4 = myQueueEmpty(obj);
//
// * myQueueFree(obj);
//*/
//
//
//
//  


//设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
//
//循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
//
//你的实现应该支持如下操作：
//
//MyCircularQueue(k) : 构造器，设置队列长度为 k 。
//Front : 从队首获取元素。如果队列为空，返回 - 1 。
//Rear : 获取队尾元素。如果队列为空，返回 - 1 。
//enQueue(value) : 向循环队列插入一个元素。如果成功插入则返回真。
//deQueue() : 从循环队列中删除一个元素。如果成功删除则返回真。
//isEmpty() : 检查循环队列是否为空。
//isFull() : 检查循环队列是否已满。
//
//
//示例：
//
//MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
//circularQueue.enQueue(1);  // 返回 true
//circularQueue.enQueue(2);  // 返回 true
//circularQueue.enQueue(3);  // 返回 true
//circularQueue.enQueue(4);  // 返回 false，队列已满
//circularQueue.Rear();  // 返回 3
//circularQueue.isFull();  // 返回 true
//circularQueue.deQueue();  // 返回 true
//circularQueue.enQueue(4);  // 返回 true
//circularQueue.Rear();  // 返回 4


//typedef struct
//{
//	int* a;
//	int front;
//	int rear;
//	int k;
//
//
//} MyCircularQueue;
//bool myCircularQueueIsFull(MyCircularQueue* obj);
//bool myCircularQueueIsEmpty(MyCircularQueue* obj);
//
//MyCircularQueue* myCircularQueueCreate(int k)
//{
//	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
//	obj->front = obj->rear = 0;
//	obj->a = (int*)malloc(sizeof(int) * (k + 1));
//	obj->k = k;
//	return obj;
//}
//
//bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
//{
//	if (myCircularQueueIsFull(obj))
//	{
//		return false;
//	}
//	obj->a[obj->rear] = value;
//	obj->rear++;
//	obj->rear %= (obj->k + 1);
//	return true;
//}
//
//bool myCircularQueueDeQueue(MyCircularQueue* obj)
//{
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return false;
//	}
//	obj->front += 1;
//	obj->front %= (obj->k + 1);
//	return true;
//}
//
//int myCircularQueueFront(MyCircularQueue* obj)
//{
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return -1;
//	}
//	return obj->a[obj->front];
//
//}
//
//int myCircularQueueRear(MyCircularQueue* obj)
//{
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return -1;
//	}
//	int x = obj->rear == 0 ? obj->k : obj->rear - 1;
//	//return obj->a[(obj->rear+obj->k)%(obj->k+1)];    
//	return obj->a[x];
//}
//
//bool myCircularQueueIsEmpty(MyCircularQueue* obj)
//{
//
//	return obj->front == obj->rear;
//}
//
//bool myCircularQueueIsFull(MyCircularQueue* obj)
//
//{
//	//1 2 3 4 空  k = 4 
//	return (obj->rear + 1) % (obj->k + 1) == obj->front;
//}
//
//void myCircularQueueFree(MyCircularQueue* obj)
//{
//	free(obj->a);
//	free(obj);
//}

// 1    2  3  4  空
//          rear     
























//10.11 树 
//#define a 10
//struct TreeNode
//{
//	struct TreeNode*arr[a];//指针数组
//	int data;
//};


//如果不知道度呢？
//struct TreeNode
//{
//	//Seqlist s1;//存放的数据类型是struct TreeNode*
//	//int data ;
//};


//左孩子右兄弟结构
//非常牛逼
//struct treeNode
//{
//	struct treeNode* firstChild1;//第一个孩子结点
//
//	struct treeNode* pNextBrother;//指向其下一个兄弟结点
//
//	int data;//结点中的数据域
//};
//int main()
//{
//
//	return 0;
//}


//二叉树

//二叉树不存在度大于2的结点

//二叉树的子树有左右之分，次序不能颠倒，所以二叉树是有序树

//满二叉树
//每一层的结点都到达了最大值
//高度为h的满二叉树有2^h-1;


//完全二叉树
// 最后一层的上一层排满了
// 最后一层必须从左到右按顺序排,连续的
//其中N1中只能为1或者0
//节点数量的范围2^h-1,2^h+-;

//在所有的二叉树中都有N0=N2+1;

//typedef int BTDATATYPE;

//二叉树
//struct TreeNode
//{
//	struct TreeNode* left;//指向当前节点左孩子
//
//	struct TreeNode* right;//指向当前节点右孩子
//	BTDATATYPE data;
//};

//节点为N的满二叉树的高度为
// 2^h-1=N
//h=log(N+1)  h=logN

//完全二叉树

//logN+1,log(N+1)

//二叉树的数据存放可以使用两种方式
//链式存储和顺序存储

//表示二叉树的值在数组位置中父子下标关系
//下标间的关系
//parent=(child-1)/2;

//leftchild=child=2*parent+1;

//rightchild=parent*2+2;

//适合满二叉树或者完全二叉树
//不适合一般的二叉树,会浪费空间

//上强度了

//堆

//堆中某个结点的值总是不大于或者不小于其父结点的值
//堆总是一颗完全二叉树

//分为小根堆和大根堆
//小根堆 树所有父亲都小于等于孩子

//大跟堆 树所有父亲大于等于孩子

//#include "snake.h"


//int main()
//{
//	HP hp;
//	HeapInit(&hp);
//	HeapPush(&hp, 4);
//	HeapPush(&hp, 8);
//	HeapPush(&hp, 2);
//	HeapPush(&hp, 81);
//	HeapPush(&hp, 18);
//	HeapPush(&hp, 28);
//	HeapPush(&hp, 83);
//	while (!HeapEmpty(&hp))
//	{
//		printf("%d ", HeapTop(&hp));
//		HeapPop(&hp);
//	}
//	printf("\n");
//	return 0;
//}
//
//









//void HeapSort(int* a, int n)
//{
//
//	//建堆
//	//然后向上调整
//	//时间复杂度是O(N*logN)
//	//T(N)=-2^h+2+2^h*h-2^h
//	//T(N)=N*logN-2N 所以T(N)=logN
//	//for (int i = 1; i < n; i++)
//	//{
//	//	upAdjust(a, i);
//	//}
//
//
//
//
//	//建堆
//	//向下调整建堆
//	//左右子树都是大堆或者小堆
//	//这个时间复杂度是O(N)
//	//T(N)=2^h-1-h
//	//N=2^h-1 N是树中节点个数
//	// h=logN
//	// 所以 T(N)=N-logN 所以T(N)=N;
//	// 
//	//所以时间复杂度是O(N)
//	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
//	{
//		downAdjust(a, n, i);
//	}
//
//
//	//排升序要建大堆，不能建小堆
//	//建小堆关系会乱套
//	//升序--大堆
//	//降序--小堆
//
//	//写一个升序
//	
//	
//	int end = n - 1;
//	while (end > 0)
//	{
//
//		Swap(&a[0], &a[end]);
//		downAdjust(a, end , 0);
//		
//		end--;
//	}//O(N)=N*logN
//
//	//冒泡排序: O(N*N)
//	//堆排序:O(N*logN)
//
//	
//}
//int main()
//{
//	int a[10] = { 2,1,5,7,6,8,0,9,4,3 };
//	int n = 10;
//	HeapSort(a, n);
//	for (int j = 0; j < 10; j++)
//	{
//		printf("%d ", a[j]);
//	}
//	return 0;
//}

//TOP-K问题

//找出N个数里面最大的前K个

//建堆N个的大堆,再POP K次就可以

//但是如果N很大呢? 比如N是100亿
//100亿个整数 大概是40个G左右

//前k个建一个小堆
//遍历剩下的数据,如果这个数据比堆顶的数据大,就代替进堆(向下调整)
//最后这个小堆的数据就是最大的前K个
//void PrintTopk(const char* file, int k)
//{
//	//用a中前k个数据建小堆
//	int* topk = (int*)malloc(sizeof(int) * k);
//	assert(topk);
//	FILE* fout = fopen(file, "r");
//	if (fout == NULL)
//	{
//		perror("fopen error");
//		return;
//	}
//
//	//读出前k个数据建小堆
//	for(int i = 0 ; i < k; i++)
//	{
//		fscanf(fout, "%d ", &topk[i]);
//	}
//	for (int j = (k - 2)/2;j>=0;j--)
//	{
//		downAdjust(topk, k, j);
//	}
//
//
//	//将剩余n-k个元素依次与堆顶元素交换,
//	int val = 0;
//	int  ret=fscanf(fout, "%d ", &val);
//	while (ret != EOF)
//	{
//		if (val > topk[0])
//		{
//			topk[0] = val;
//			downAdjust(topk, k, 0);
//		}
//		ret = fscanf(fout, "%d ", &val);
//	}
//	for (int i = 0; i < k; i++)
//	{
//		printf("%d ", topk[i]);
//	}
//	free(topk);
//	fclose(fout);
//}
//void CreateNDate()
//{
//	int n = 10000;
//	srand((unsigned int)time(NULL));
//	const char* file = "num.txt";
//	FILE* fin = fopen(file, "w");
//	if (fin == NULL)
//	{
//		perror("fopen error");
//		return;
//	}
//
//	for (int i = 0; i < n; i++)
//	{
//		int x = rand() % 10000+1;
//		fprintf(fin, "%d\n", x);
//	}
//	fclose(fin);
//
//	//PrintTopk(fin, 10);
//}
//int main()
//{
//	CreateNDate();
//	PrintTopk("num.txt", 10);
//	return 0;
//}
//














//一般的二叉树 链式结构实现

//普通二叉树没有意义,搜索二叉树有意义
//可以用来快速查找


//普通二叉树

//前序遍历 根 左子树 右子树
// 
//中序遍历 左子树 根 右子树
// 
//后序遍历 左子树 右子树 根
// 
//层序遍历  按照每一层来

//根 左子树 右子树
//typedef int BTDATATYPE;
//typedef struct BinaryTreeNode
//{
//	BTDATATYPE data;
//	struct BinaryTreeNode* left;
//	struct BinaryTreeNode* right;
//
//}BTNode;
//二叉树的层序打印
//void LEVELOrder(BTNode* root)
//{
//	Queue q;//创建一个队列 其中typedef struct BinaryTreeNode *是datatype
//	QueueInit(&q);
//	if (root)
//	{
//		Queuepush(&q, root);
//	}
//	while (!QueueEmpty(&q))
//	{
//		BTNode* front = QueueFront(&q);
//		QueuePop(&q);
//		printf("%d ", front->data);
//	
//	if (front->left)
//	{
//		QueuePush(&q, front->left)
//	}
//	if (front->right)
//		{
//			QueuePush(&q, front->right)
//		}
//	}
//	QueueDestroy(&q);
//
//}

////二叉树查找值为x的结点
//BTNode* Find(BTNode* root, BTDATATYPE x)
//{
//	if (root == NULL)
//	{
//		return NULL;
//	}
//	if (root->data == x)
//	{
//		return root;
//	}
//	BTNode* lret = Find(root->left, x);
//		if (lret)
//		{
//			return lret;
//		}
//		BTNode* rret = Find(root->right, x);
//		if (rret)
//		{
//			return rret;
//		}
//		return NULL;
//}
//BTNode* BuyNode(BTDATATYPE x)
//{
//	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
//	if (node == NULL)
//	{
//		perror("malloc");
//		return NULL;
//	}
//	node->data = x;
//	node->left = NULL;
//	node->right = NULL;
//	return node;
//}
//BTNode* CreateTree()
//{ 
//	BTNode* node1 = BuyNode(1);
//	BTNode* node2 = BuyNode(2);
//	BTNode* node3 = BuyNode(3);
//	BTNode* node4 = BuyNode(4);
//	BTNode* node5 = BuyNode(5);
//	BTNode* node6 = BuyNode(6);
//	BTNode* node7 = BuyNode(7);
//	node1->left = node2;
//	node1->right = node4;
//	node2->left = node3;
//	node4->left = node5;
//	node4->right = node6;
//	node3->left = node7;
//	return node1;
//
//}
//void PrevOrder(BTNode *root)
//{
//	if (root == NULL)
//	{
//		printf("NULL ");
//		return;
//	}
//	printf("%d ", root->data);
//	PrevOrder(root->left);
//	PrevOrder(root->right);
//}
//void InOrder(BTNode* root)
//{
//	if (root == NULL)
//	{
//		printf("NULL ");
//		return;
//	}
//	InOrder(root->left);
//	printf("%d ", root->data);
//	
//	InOrder(root->right);
//}
//void PostOrder(BTNode* root)
//{
//	if (root == NULL)
//	{
//		printf("NULL ");
//		return;
//	}
//	PostOrder(root->left);
//	PostOrder(root->right);
//	printf("%d ", root->data);
//
//	
//}
////int size = 0;
//void TreeSize(BTNode* root)
//{
//	if (root == NULL)
//	{
//		return;
//	}
//	TreeSize(root->left);
//	size++;
//	TreeSize(root->right);
//
//
//}

//void TreeSize(BTNode* root,int *psize)
//{
//	if (root == NULL)
//	{
//		return;
//	}
//	TreeSize(root->left,psize);
//	(*psize)++;
//	TreeSize(root->right,psize);
//
//
//}
//
//int TreeSize(BTNode* root)
//{
//	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
//}
//int TreeHeight(BTNode* root)
//{
//	if (root == NULL)
//	{
//		return 0;
//	}
//	int left = TreeHeight(root->left);
//	int right = TreeHeight(root->right);
//	return left > right ? left + 1 : right + 1;
//
//}
//int TreeKLevel(BTNode* root, int k)
//{
//	//根的第k层个数=左子树的第k-1层个数+右子树的第k-1层个数
//	if (root == NULL)
//	{
//		return NULL;
//   }
//	if (k == 1)
//	{
//		return 1;
//	}
//	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
//
//
//}

//int main()
//{
//	BTNode* root = CreateTree();
//	//PrevOrder(root);
//	//InOrder(root);
//	//PostOrder(root);
//	int size = 0;
//	//TreeSize(root,&size);
//	/*size = 0;
//	TreeSize(root);*/
//	//TreeSize(root);
//
//	//printf("%d ", TreeSize(root));
//	//printf("%d ", TreeHeight(root));
//	printf("%d ", TreeKLevel(root, 3));
//	printf("%d ", TreeKLevel(root, 4));
//	return 0;
//}

//只有给定的树是单值二叉树时，才返回 true；否则返回 false
//struct treenode {
//	int val;
//	struct treenode* left;
//	struct treenode* right;
//	
// 
//};
//
//bool isUnivalTree(struct TreeNode* root)
//{
//	if (root == NULL)
//	{
//		return true;
//	}
//	if (root->left && root->left->val != root->val)
//	{
//		return false;
//	}
//	if (root->right && root->right->val != root->val)
//	{
//		return false;
//	}
//	return isUnivalTree(root->left) && isUnivalTree(root->right);
//}

//给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

//bool isSameTree(struct TreeNode* p, struct TreeNode* q)
//{
//	if (q == NULL && p == NULL)
//	{
//		return true;
//	}
//	if (q == NULL || p == NULL)
//	{
//		return false;
//	}
//	if (p->val != q->val)
//	{
//		return false;
//	}
//	return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
//
//}

//给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。
//
//二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
//bool isSameTree(struct TreeNode* p, struct TreeNode* q)
//{
//	if (q == NULL && p == NULL)
//	{
//		return true;
//	}
//	if (q == NULL || p == NULL)
//	{
//		return false;
//	}
//	if (p->val != q->val)
//	{
//		return false;
//	}
//	return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
//
//}
//bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
//{
//	if (root == NULL)
//	{
//		return false;
//	}
//	if (isSameTree(root, subRoot))
//	{
//		return true;
//	}
//	return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
// 

//bool TreeComplete(BTNode* root)
//{
//	Queue q;
//	QueueInit(&q);
//	if (root)
//		QueuePush(&q, root);
//
//	while (!QueueEmpty(&q))
//	{
//		BTNode* front = QueueFront(&q);
//		QueuePop(&q);
//
//		// 遇到第一个空，就可以开始判断，如果队列中还有非空，就不是完全二叉树
//		if (front == NULL)
//		{
//			break;
//		}
//
//		QueuePush(&q, front->left);
//		QueuePush(&q, front->right);
//	}
//
//	while (!QueueEmpty(&q))
//	{
//		BTNode* front = QueueFront(&q);
//		QueuePop(&q);
//
//		// 如果有非空，就不是完全二叉树
//		if (front)
//		{
//			QueueDestroy(&q);
//			return false;
//		}
//	}
//
//	QueueDestroy(&q);
//	return true;
//}


//void TreeDestory(BTNode* root)
//{
//	if (root == NULL)
//		return;
//
//	TreeDestory(root->left);
//	TreeDestory(root->right);
//	free(root); //此处没有必要把root置为NULL 因为形参的改变并不影响实参
//}












//排序
//启动




//常见排序算法  --插入排序 --直接插入排序和希尔排序
               //--选择排序    --选择排序和堆排序
                //交换排序 --冒泡排序 快速排序
				// 归并排序  --归并排序      









//直接插入排序
//void insertsort(int* a, int n)
//{
//
//	for (int i = 1; i < n - 1; i++)
//	{
//		int end = i - 1;
//		int tmp = a[end + 1];
//
//		while (end >= 0)
//		{
//			if (tmp < a[end])
//			{
//				a[end + 1] = a[end];
//				end--;
//			}
//			else
//			{
//				break;
//			}
//		}
//
//		a[end + 1] = tmp;
//	}
//
//}
//
//
//int main()
//{
//	int arr[10] = { 1,5,8,9,0,6,11,2,3,4 };
//	insertsort(arr, 10);
//	for (int j = 0; j < 10; j++)
//	{
//		printf("%d ", arr[j]);
//	}
//
//
//	return 0;
//}
//void Insertsort(int* a, int n)
//{
//	for (int i = 0; i < n - 1; i++)
//	{
//		int end = i;
//		int tmp = a[end + 1];
//		while (end >= 0)
//		{
//			if (a[end] > tmp)
//			{
//				a[end + 1] = a[end];
//				end--;
//			}
//			else
//			{
//				break;
//			}
//			a[end + 1] = tmp;
//		}
//	}
//
//}
//void Print(int* a,int i)
//{
//	for (int j = 0; j < i; j++)
//	{
//		printf("%d ", a[j]);
//	}
//	printf("\n");
//}
//int main()
//{
//	int a[10] = { 1,2,5,7,8,4,12,6,11,2 };
//	//插入排序 时间复杂度最坏情况下为O(N^2)
//	//最好情况下为O(N)
//	Insertsort(a, sizeof(a) / sizeof(a[0]));
//	Print(a, sizeof(a) / sizeof(a[0]));
//
//
//	return 0;
//}
















//希尔排序 
//1.预排序--目标:数组接近有序
//2.直接插入排序
//间隔为gap的分为一组,对每组数据插入排序
//5 1 2 8 7 4 9 6 3 5  
//void Shellsort(int* a, int n)
//
//{
//	int gap = 3;
	/*for (int j = 0; j < gap; j++)
	{
		for (int i = j; i < n - gap; i += gap)
		{

			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
				a[end + gap] = tmp;
			}
		}
	}*/
	
	/*
	int gap = 3;
	for (int i = gap; i < n; i+=gap)
	{
	
		int end = i - gap;
		int tmp = a[end + gap];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + gap] = a[end];
				end -= gap;
			}
			else
			{
				break;
			}
			a[end + gap] = tmp;
		}
	}
	*/

//}
void QuickSort(int* a, int left, int right);
void Print(int* a,int i)
{
	for (int j = 0; j < i; j++)
	{
		printf("%d ", a[j]);
	}
	printf("\n");
}
//void Shellsort(int* a, int n)
//{
//	int gap = n;
//	while (gap > 1)
//	{
//		gap = gap / 3 + 1;
//		for (int i = 0; i < n - gap; i++)
//		{
//
//			int end = i;
//			int tmp = a[end + gap];
//			while (end >= 0)
//			{
//				if (tmp < a[end])
//				{
//					a[end + gap] = a[end];
//					end -= gap;
//				}
//				else
//				{
//					break;
//				}
//				a[end + gap] = tmp;
//			}
//		}
//		//Print(a, n);
//
//	}
	//5 1 2 8 7 4 9 6 3 5
	//这么写与上面结果完全一样,效率也完全一样,只不过这个代码更简洁一点
	//gap越大,跳的越快,越不接近于有序
	//gap越小,跳的越慢,越不接近于有序
	//gap越小
//时间复杂度不是N*log(N)需要具体分析
//结论 时间复杂度大概是O(N^1.3)
//无法确定gap什么时时间复杂度最小
//未解之谜
//

		
	
//}





////排序过程中的试金石
//void TestOP()
//{
//	srand((unsigned int)time(NULL));
//	const int N = 1000000;
//	int* a1 = (int*)malloc(sizeof(int) * N);
//	int* a2 = (int*)malloc(sizeof(int) * N);
//	int* a3 = (int*)malloc(sizeof(int) * N);
//	int* a4 = (int*)malloc(sizeof(int) * N);
//	int* a5 = (int*)malloc(sizeof(int) * N);
//	int* a6 = (int*)malloc(sizeof(int) * N);
//	int* a7 = (int*)malloc(sizeof(int) * N);
//
//	for (int i = 0; i < N; ++i)
//	{
//		a1[i] = rand() + i;
//		a2[i] = a1[i];
//		a3[i] = a1[i];
//		a4[i] = a1[i];
//		a5[i] = a1[i];
//		a6[i] = a1[i];
//		a7[i] = a1[i];
//	}
//
//	//int begin1 = clock();
//	//Insertsort(a1, N);
//	//int end1 = clock();
//
//	int begin2 = clock();
//	Shellsort(a2, N);
//	int end2 = clock();
//	//printf("Insertroot:%d", end1 - begin1);
//	printf("Shellsort:%d", end2 - begin2);
//
//
//
//	free(a1);
//	free(a2);
//}
//
//
//
//
















//int main()
//{
//	//int a[] = {5 ,1, 2, 8 ,7 ,4 ,9 ,6 ,3 ,5,11};
//	//size_t sz = sizeof(a) / sizeof(a[0]);
//	//shellsort(a, sz);
//	TestOP();
//	
//
//	return 0;
//}


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}




//选择排序
//void SelectSort(int *a,int n)
//{
//	//时间复杂度 O(N^2)
//	// 最好情况下是这个
//	// 最坏情况下也是这个
//	// 因为这个选择排序在硬整
//	//比较烂的排序
//	int left = 0;
//	int right = n - 1;
//	//0 
//	while (left < right)
//	{
//		int min = left, max = left;
//		for (int i = left; i <= right; i++)
//		{
//			if (a[i] < a[min])
//			{
//				min = i;
//			}
//			if (a[i] > a[max])
//			{
//				max = i;
//			}
//		}
//
//		
//		
//		if (left == max)
//		{
//			max = min;
//		}
//		//0 1 2 3 4 5 6 7 8 9
//		//
//		//10 1 2 3 4 5 6 7 8 9
//		// 1 10 2 3 4 5 6 7 8 9
//		//left 0 max 1 right 9 min 1
//		Swap(&a[left], &a[min]);//如果left等于了max 可以把min赋给max
//			//第一步执行完就完了
//
//			Swap(&a[right], &a[max]);
//		
//
//
//		left++;
//		right--;
//	}
//
//}

//int main()
//{
//	int a[] = { 1,3,3,7,9,2,4,6,8,10 };
//	SelectSort(a, sizeof(a) / sizeof(a[0]));
//	Print(a, sizeof(a) / sizeof(a[0]));
//	
//	return 0;
//}













//堆排序 
//时间复杂度是O(N*logN)
//先向上建堆 在排序

//void Adjustdown(int* a, int n, int parent)
//{
//	int child = parent * 2 + 1;
//	while (child < n)
//	{
//	if (child + 1 < n && a[child] < a[child + 1])
//	{
//		child++;
//	}
//	
//		if (a[parent] < a[child])
//		{
//			Swap(&a[parent], &a[child]);
//			parent = child;
//			child = parent * 2 + 1;
//		}
//		else
//		{
//			break;
//		}
//	}
//}

//
//void HeapSort(int* a, int n)
//{
//	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
//	{
//		Adjustdown(a, n, i);
//
//	}
//
//	int end = n - 1;
//	while (end)
//	{
//		Swap(&a[0], &a[end]);
//		Adjustdown(a, end, 0);
//		end--;
//	}
//
//}

//void SelectSort(int* a, int n)
//{
//	int left = 0, right = n - 1;
//	while (left < right)
//	{
//		int min=left, max=left;
//
//		for (int i = left; i < right+1; i++)
//		{
//			if (a[min] > a[i])
//			{
//				min = i;
//			}
//			if (a[max] < a[i])
//			{
//				max = i;
//			}
//		}
//		Swap(&a[left], &a[min]);
//		if (left == max)
//		{
//			max = min;
//		}
//		Swap(&a[right], &a[max]);
//		left++;
//		right--;
//	}
//}
//1 2 3 4 4 5 6 7 4

void InsertSort(int *a,int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
                  //end tmp
//1 2 2 3 4 5  6 7 8 7 2
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap)
	{
		gap /= 2;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while(end >=0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
				a[end + gap] = tmp;
			}
		}
	}
}


















//冒泡排序 时间复杂度 最好O(N)最坏O(N^2)
// /与直接插入排序的时间复杂度类似,但是直接插入排序会更好 直接插入排序中会一块一块的接近有序,就会导致时间更少
// 
//void BubbleSort(int* a,int n)
//{
//	for (int i = 0; i < n - 1; i++)
//	{
//		for (int j = 0; j < n - i - 1; j++)
//		{
//			if (a[j] > a[j + 1])
//			{
//				Swap(&a[j], &a[j + 1]);
//			}
//
//		}
//	}
//}
//int main()
//{
//	int a[] = { 2,5,1,3,3,4,8,9,10,7 };
//	//HeapSort(a, sizeof(a) / sizeof(a[0]));
//	//SelectSort(a, sizeof(a) / sizeof(a[0]));
//	//InsertSort(a, sizeof(a) / sizeof(a[0]));
//	//ShellSort(a, sizeof(a) / sizeof(a[0]));
//	BubbleSort(a, sizeof(a) / sizeof(a[0]));
//	Print(a, sizeof(a) / sizeof(a[0]));
//
//	return 0;
//}














int GetMiddle(int* a, int left, int right)
{
	//
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else //a[left]>a[mid]
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}



//快速排序 
//最牛逼的
//选出一个关键值key,把他放到正确的位置(最终排好序要蹲的位置)
//比key小的放左边,比key大的放右边,key就是正确的位置
//key left right
//左边是key 右边先走
//右边是key,左边先走
//找到之后交换
//左边找大,右边找小
//相遇位置一定比key小
//右边为key左边先走，相遇位置一定比key大
//void QuickSort(int* a, int left,int right)
//{
//	if (left >= right)
//	{
//		return;
//	}
//
//	int begin = left;
//	int end = right;
//
//	//随机选key 
//	/* int ran = left + (rand() % (right - left));
//	Swap(&a[left], &a[ran]);*/
//
//
//	//三数取中
//	//int mid = GetMiddle(a, left, right);
//	//Swap(&a[mid], &a[left]);
//
//
//
//	int key = left;
//	while (left < right)
//	{
//		while (left < right&&a[right] >= a[key])
//		{
//			right--;
//		}
//		while (left < right&&a[left] <= a[key])
//		{
//			left++;
//		}
//		Swap(&a[left], &a[right]);
//
//	}
//	
//	Swap(&a[key], &a[left]);
//	key = left;
//	//begin key-1   key    key+1,end
//	//递归
//	QuickSort(a, begin, key - 1);
//	QuickSort(a, key + 1, end);
//
//
//} 
//时间复杂度可以认为成N*log(N) 但实际上比这个要小
// 就是顺序的时候会成一个等差数列
// 这种情况下是因为key每次都是最左边的,所以有人提出一个随机选key
// 最坏是O(N^2) 还容易栈溢出
// 
//2 3 45



//
//void QuickSort(int* a, int left,int right)
//{
//	if (left >= right)
//	{
//		return;
//	}
//
//	int begin = left;
//	int end = right;
//
//
//	int key = left;
//	while (left < right)
//	{
//		while (left < right&&a[right] >= a[key])
//		{
//			right--;
//		}
//		while (left < right&&a[left] <= a[key])
//		{
//			left++;
//		}
//		Swap(&a[left], &a[right]);
//
//	}
//	
//	Swap(&a[key], &a[left]);
//	key = left;
//	//begin key-1   key    key+1,end
//	//递归
//	QuickSort(a, begin, key - 1);
//	QuickSort(a, key + 1, end);
//
//
//} 
//挖坑法
//void QuickSort1(int* a, int left, int right)
//{
//	
//	if (left >= right)
//	{
//		return;
//	}
//	hole     left right hole
//	1 2 3 4 5 6 7 8
//	int begin = left;
//	int end = right;
//	int key = a[left];
//	int hole = left;
//	while (left < right)
//	{
//		while (left < right && a[right] >= key)
//		{
//			right--;
//		}
//		a[hole] = a[right];
//		hole = right;
//		while (left < right && a[left] <= key)
//		{
//			left++;
//		}
//		a[hole] = a[left];
//		hole = left;
//
//	}
//
//	a[hole] = key;
//
//	begin key-1   hole    key+1,end
//	递归
//	QuickSort1(a, begin, hole - 1);
//	QuickSort1(a, hole + 1, end);
//
//
//}










//
//
//int PartSort1(int* a, int left, int right)
//{
//	
//
//	int begin = left;
//	int end = right;
//
//	
//	/*int mid = GetMiddle(a, left, right);
//	Swap(&a[mid], &a[left]);*/
//
//	int key = left;
//
//
//	while (left < right)
//	{
//		while (left < right && a[right] >= a[key])
//		{
//			right--;
//		}
//		while (left < right && a[left] <= a[key])
//		{
//			left++;
//		}
//		Swap(&a[left], &a[right]);
//
//	}
//	Swap(&a[key], &a[left]);
//	key = left;
//	
//	return key;
//}
//挖坑法
//int PartSort2(int* a, int left, int right)
//{	
//	
//	int key = a[left];
//	int hole = left;
//	while (left < right)
//	{
//		while (left < right && a[right] >= key)
//		{
//			right--;
//		}
//		a[hole] = a[right];
//		hole = right;
//		while (left < right && a[left] <= key)
//		{
//			left++;
//		}
//		a[hole] = a[left];
//		hole = left;
//
//	}
//
//	a[hole] = key;
//
//	return hole;
//}

int PartSort3(int* a, int left, int right)
{   //prev  prev   
	//      cur   cur
	//left 
	//6      1     2     7    9    3 4 5 10 8
	int mid = GetMiddle(a, left, right);
	if(mid!=left)
	Swap(&a[mid], &a[left]);

	int key = left;
	int cur = left + 1, prev = left;
	while (cur <= right)
	{

		if (a[cur] < a[key] && ++prev != cur)
		{
			Swap(&a[cur], &a[prev]);
		}
		++cur;
	}
	Swap(&a[key], &a[prev]);
	key = prev;
	return key;

}





//
//void TestOP()
//{
//	
//	const int n = 1000000;
//	int* a1 = (int*)malloc(sizeof(int) * n);
//	int* a2 = (int*)malloc(sizeof(int) * n);
//	int* a3 = (int*)malloc(sizeof(int) * n);
//	int* a4 = (int*)malloc(sizeof(int) * n);
//	int* a5 = (int*)malloc(sizeof(int) * n);
//	int* a6 = (int*)malloc(sizeof(int) * n);
//	int* a7 = (int*)malloc(sizeof(int) * n);
//
//	for (int i = 0; i < n; ++i)
//	{
//		a1[i] = rand() + i;
//		a2[i] = a1[i];
//		a3[i] = a1[i];
//		a4[i] = a1[i];
//		a5[i] = a1[i];
//		a6[i] = a1[i];
//		a7[i] = a1[i];
//	}
//
//	int begin1 = clock();
//	QuickSort(a1,0, n-1);
//	int end1 = clock();
//
//	int begin2 = clock();
//	ShellSort(a2, n);
//	int end2 = clock();
//	printf("QuickSort:%d", end1 - begin1);
//	printf("shellsort:%d", end2 - begin2);
//
//	int begin3 = clock();
//	//quicksort1(a3, 0,n -1);
//	int end3 = clock();
//	//printf("quicksort:%d", end3 - begin3);
//
//	free(a1);
//	free(a2);
//	free(a3);
//	free(a4);
//	free(a5);
//	free(a6);
//	free(a7);
//}

//void QuickSort(int* a, int left, int right)
//{
//	if (left >= right)
//	{
//		return;
//	}
//
//	//小区间优化 小区间直接去用直接插入排序
//	/*if ((right - left + 1) > 20)
//	{*/
// 		int key1 = PartSort2(a, left, right);
//		QuickSort(a, left, key1 - 1);
//		QuickSort(a, key1 + 1, right);
//	//}
//	/*else
//	{
//		InsertSort(a+left, right - left + 1);
//	}*/
//}


//int main()
//{
//	srand((unsigned int)time(NULL));
//	int a[] = { 2,3,4,8,9,1,0,5,7,8 };
//	//QuickSort1(a, 0, sizeof(a) / sizeof(a[0])-1);
//	
//	//Print(a, sizeof(a) / sizeof(a[0]));
//	
//	TestOP();
//	//QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
//	//Print(a, sizeof(a) / sizeof(a[0]));
//
//	return 0;
//}

//int main()
//{
//	char c;
//	int i;
//	for (i = 1; i <= 5; i++)c = getchar();
//	if (c >= 'a' && c <= 'u')c += 5;
//	else if (c >= 'v' && c <= 'z')c = 'a' + c - 'v';
//	putchar(c);
//
//
//	return 0;
//}
//int main()
//{
//	int i=0, j=0;
//	for (i = 1, j = 1; j < 5; j++)
//	{
//
//	}
//	i = (3 * 4, i * 4);
//	printf("%d%d", i, j);
//	return 0;
//}


//递归的问题
//1.效率  影响不是很大
//2.深度问题，有可能会栈溢出
//要把递归改为非递归
//1.直接改循环 斐波那契数列
//2.使用栈辅助改成循环



#include "snake.h"
//非递归实现快速排列 利用栈来实现
//void QuickSortNone(int* a, int left, int right)
//{
//	ST st;
//	STInit(&st);
//	STPush(&st, right);
//	STPush(&st, left);
//	while (!STEmpty(&st))
//	{
//		int begin = STTop(&st);
//		STPop(&st);
//		int end = STTop(&st);
//		STPop(&st);
//		int key = PartSort3(a, begin, end);
//		// begin key end
//		if (key + 1 < end)
//		{
//			STPush(&st, end);
//			STPush(&st, key + 1);
//
//		}
//		if (begin < key - 1)
//		{
//			STPush(&st, key - 1);
//			STPush(&st, begin);
//		}
//
//	}
//
//	STDestroy(&st);
//
//}
//int main()
//{
//	srand((unsigned int)time(NULL));
//	int a[] = { 2,3,4,8,9,1,0,5,7,8 };
//	//QuickSort1(a, 0, sizeof(a) / sizeof(a[0])-1);
//	QuickSortNone(a, 0, sizeof(a) / sizeof(a[0])-1);
//
//	Print(a, sizeof(a) / sizeof(a[0]));
//	
//	//TestOP();
//	//QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
//	//Print(a, sizeof(a) / sizeof(a[0]));
//
//	return 0;
//}

//}
//int main()
//{
//	srand((unsigned)time(NULL));
//	int x = rand();
//	printf("%d", x);
//
//	return 0;
//}



//#include<string.h>
//int main()
//{
//	char c[100];
//	gets(c);
//	char max = c[0];
//	int len = strlen(c);
//	int i = 0;
//	while (c[i] != '\0')
//	{
//		if (c[i] > max)
//		{
//			max = c[i];
//		}
//		i++;
//	}
//	printf("%c", max);
//	return 0;
//}
//#include<stdio.h>
//int main()
//{
//	int i = 0;
//	scanf("%d", &i);
//	int a[1000];
//	int count = i;
//	for (int j = 0; j < i; j++)
//	{
//		scanf("%d", &a[j]);
//		
//	}
//	for (int q = 0; q < i; q++)
//	{
//		for (int w = q + 1; w < i; w++)
//		{
//			if (a[q] == a[w])
//			{
//				count--;
//			}
//		}
//	}
//	printf("%d", count);
//	return 0;
//}
//#include<stdio.h>
//int main()
//{
//	int i = 0;
//	scanf("%d", &i);
//	int a[1000];
//	int x;
//	int count = i;
//	for (int j = 0; j < i; j++)
//	{
//		scanf("%d", &a[j]);
//	}
//
//	//1 1 1 1 1 2 2
//	for (int q = 0; q < i; q++)
//	{
//		for (int w = q + 1; w < i; w++)
//		{
//			if (a[w] == a[q])
//			{
//				count--;
//				//x = a[w];
//
//			}
//			
//		}
//	}
//	printf("%d", count);
//	return 0;
//}













//归并排序
//两个有序区间归并
//一次比较，小的尾插到新空间
//时间复杂度N*logN
//void _MergeSort(int* a, int begin, int end, int* tmp)
//{
//	if (begin >= end)
//	{
//		return;
//	}
//	int mid = (begin + end) / 2;
//	/*_MergeSort(a, begin, mid, tmp);
//	_MergeSort(a,mid+1, end, tmp);*/
//	//begin mid mid+1 end
//	int begin1 = begin, end1 = mid;
//	int begin2 = mid + 1, end2 = end;
//	_MergeSort(a, begin1, end1, tmp);
//	_MergeSort(a, begin2, end2, tmp);
//	
//	int i = begin;
//	while (begin1 <= end1 && begin2 <= end2)
//	{
//		if (a[begin1] < a[begin2])
//		{
//			tmp[i++] = a[begin1++];
//			
//			
//		}
//		else
//		{
//			tmp[i++] = a[begin2++];
//			
//		}
//	}
//	while (begin1 <= end1)
//	{
//		tmp[i++] = a[begin1++];
//		
//	}
//	while (begin2 <= end2)
//	{
//		tmp[i++] = a[begin2++];
//		
//	}
//	memcpy(a + begin, tmp + begin, sizeof(int)*(end - begin + 1));
//}
//void MergeSort(int* a, int n)
//{
//	int* tmp = (int*)malloc(sizeof(int) * n);
//	if (tmp == NULL)
//	{
//		perror("malloc");
//		return;
//	}
//	_MergeSort(a, 0, n - 1, tmp);
//	free(tmp);
//}
//


//每一次都拷贝,直接一把梭哈
//void MergeSortNone(int* a, int n)
//{
//	
//	int* tmp = (int*)malloc(sizeof(int) * n);
//	if (tmp == NULL)
//	{
//		perror("malloc");
//		return;
//	}
//	//1 2 3 4 4 5 6 7 7 8 9 10
//	int gap = 1;
//	while(gap < n)
//	{
//		for (int i = 0; i < n; i += 2*gap)
//		{
//			int begin1 = i, end1 = i + gap - 1;
//			int begin2 = i + gap, end2 = i + 2 * gap - 1;
//			int j = i;
//			if (end1 >= n)
//			{
//				end1 = n - 1;
//				begin2 = n;
//				end2 = n-1;
//			}
//			else if (begin2 >= n)
//			{
//				begin2 = n;
//				end2 = n-1;
//			}
//			else if (end2 >= n)
//			{
//				end2 = n - 1;
//			}
//			while (begin1 <= end1 && begin2 <= end2)
//			{
//				if (a[begin1] < a[begin2])
//				{
//					tmp[j++] = a[begin1++];
//
//
//				}
//				else
//				{
//					tmp[j++] = a[begin2++];
//
//				}
//			}
//			while (begin1 <= end1)
//			{
//				tmp[j++] = a[begin1++];
//
//			}
//			while (begin2 <= end2)
//			{
//				tmp[j++] = a[begin2++];
//
//			}
//		}
//		gap *= 2;
//		memcpy(a, tmp, sizeof(int) * n);
//	}
//	
//
//
//
//
//	free(tmp);
//}



//void MergeSortNone(int* a, int n)
//{
//
//	int* tmp = (int*)malloc(sizeof(int) * n);
//	if (tmp == NULL)
//	{
//		perror("malloc");
//		return;
//	}
//	//1 2 3 4 4 5 6 7 7 8 9 10
//	int gap = 1;
//	while (gap < n)
//	{
//		for (int i = 0; i < n; i += 2 * gap)
//		{
//			int begin1 = i, end1 = i + gap - 1;
//			int begin2 = i + gap, end2 = i + 2 * gap - 1;
//			int j = i;
//			if (end1 >= n || (begin2 >= n))
//			{
//				break;
//			}
//			 
//	    if (end2 >= n)
//			{
//				end2 = n - 1;
//			}
//			while (begin1 <= end1 && begin2 <= end2)
//			{
//				if (a[begin1] < a[begin2])
//				{
//					tmp[j++] = a[begin1++];
//
//
//				}
//				else
//				{
//					tmp[j++] = a[begin2++];
//
//				}
//			}
//			while (begin1 <= end1)
//			{
//				tmp[j++] = a[begin1++];
//
//			}
//			while (begin2 <= end2)
//			{
//				tmp[j++] = a[begin2++];
//
//			}
//
//			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i+1));//闭区间得加1
//		}
//		gap *= 2;
//		
//	}
//
//
//
//
//
//	free(tmp);

//void MergeSortNone(int* a, int n)
//{
//	//1 2 3 4 5 5 6 7 8 8 9  
//	int* tmp = (int*)malloc(sizeof(int) * n);
//	int gap = 1;
//	while (gap < n)
//	{
//		int j = 0;
//		for (int i = 0; i < n; i+=2*gap)//排完之后i每次应该走2*gap个
//		{
//			int begin1 = i, end1 = i + gap - 1;
//			int begin2 = i + gap, end2 = i + 2 * gap - 1;
//			if (end1 >= n)
//			{
//				end1 = n - 1;
//				begin2 = n, end2 = n - 1;
//			}
//			else if (begin2>= n)
//			{
//				begin2 = n, end2 = n - 1;
//			}
//			else if (end2 >= n)
//			{
//				end2 = n - 1;
//			}
//			while(begin1<=end1&&begin2<=end2)
//			{
//
//				if (a[begin1] < a[begin2])
//				{
//					tmp[j++] = a[begin1++];
//				}
//				else
//				{
//					tmp[j++] = a[begin2++];
//				}
//
//			}
//			while (begin1 <= end1)
//			{
//				tmp[j++] = a[begin1++];
//			}
//			while (begin2 <= end2)
//			{
//				tmp[j++] = a[begin2++];
//			}
//		}
//		memcpy(a, tmp, sizeof(int) * n);
//		gap *= 2;
//	}
//
//	
//}
//
//
//void _MergeSort(int* a, int left, int right, int* tmp)
//{
//	if (left >= right)
//	{
//		return;
//	}
//	int mid = (left + right) / 2;
//	int begin1 = left, end1 = mid, begin2 = mid + 1, end2 = right;
//	_MergeSort(a, begin1, end1, tmp);
//	_MergeSort(a, begin2, end2, tmp);
//	int i = left;
//	while (begin1 <= end1 && begin2 <= end2)
//	{
//		if (a[begin1] < a[begin2])
//		{
//			tmp[i++] = a[begin1++];
//		}
//		else
//		{
//			tmp[i++] = a[begin2++];
//		}
//
//	}
//	while (begin1 <= end1)
//	{
//		tmp[i++] = a[begin1++];
//	}
//	while (begin2 <= end2)
//	{
//		tmp[i++] = a[begin2++];
//	}
//	memcpy(a + left, tmp + left, sizeof(int) * (right - left + 1));
//	
//}
void MergeSortNone(int* a, int n)
{
	//1 2 3 4 5 5 6 7 8 8 9  
	int* tmp = (int*)malloc(sizeof(int) * n);
	int gap = 1;
	while (gap < n)
	{
		int j = 0;
		for (int i = 0; i < n; i += 2 * gap)//排完之后i每次应该走2*gap个
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}

			while (begin1 <= end1 && begin2 <= end2)
			{

				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}

			}
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}

		gap *= 2;
	}

}
//void MergeSort(int* a, int n)
//{
//	int* tmp = (int*)malloc(sizeof(int)*n);
//	if (tmp == NULL)
//	{
//		perror("malloc");
//		return;
//	}
//	_MergeSort(a, 0, n - 1, tmp);
//
//	free(tmp);
//
//}
void CountSort(int* a, int n)
{
	int max = a[0];
	int min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int range = max - min + 1;

	int* tmp = (int*)calloc(range, sizeof(int));
	for(int i=0;i<n;i++)
	{
		tmp[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i <range; i++)
	{
		while (tmp[i]--)
		{
			a[j++] = i + min;
		}

	}

}
void SelectSort(int* a, int n)
{
	int left = 0, right = n - 1;
	
	while(left < right)
   {
		int mini = left, maxi = left;
		for (int i = left; i <= right; i++)
		{
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
			if (a[i] < a[mini])
			{
				mini = i;
			}
		}
		//10 
		Swap(&a[left], &a[mini]);
			if (left == maxi)
			{
				maxi = mini;
			}
		Swap(&a[maxi], &a[right]);
			left++;
			right--;
	}
}
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	
	while (child  <  n)
	{
		if (child+1<n&&a[child] < a[child + 1])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
			
		}
		else
		{
			break;
		}
	}


}
void HeapSort(int* a, int n)
{
	//1.建大堆
	for (int i = (n - 1 - 1)/2;i>=0 ; i--)
	{
		AdjustDown(a, n, i);
	}

	//2.排序
	int end = n - 1;
	while(end>0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}

}
void QuickSort1(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int begin = left;
	int end = right;

	
	int mid=GetMiddle(a, left, right);
	Swap(&a[mid], &a[left]);
	int key = left;
	
	while (left < right)
	{
		while (left<right && a[right]>=a[key])
		{
			right--;
		}
		while (left<right && a[left]<=a[key]);
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	QuickSort1(a, begin, key-1);
	QuickSort1(a, key + 1, end);


}
// 快速排序挖坑法
void QuickSort2(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int hole = left;
	int begin = left;
	int end = right;
	int key = a[left];
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
		a[hole] = key;
		QuickSort2(a, begin, hole - 1);
		QuickSort2(a, hole + 1, end);

}
// 快速排序前后指针法
void QuickSort3(int* a, int left, int right)
{   //    prev    cur
	//30, 15, 40, 28, 50, 10, 70
	if (left >= right)
	{
		return;
	}
	int begin = left;
	int end = right;
	int cur = left + 1, prev = left;
	int key = left;
	while (cur <= right)
	{
		/*if (a[cur] < a[key] && prev++ != cur)
		{
			Swap(&a[cur], &a[prev]);
		}*/
		if (a[cur] >= a[key])
		{
			cur++;
		}
		else 
		{	
			if (prev++ == cur)
			{

			}
			else
			{
				Swap(&a[prev], &a[cur]);
			}
			cur++;
		}
	}
	Swap(&a[prev], &a[key]);
	key = prev;

	QuickSort3(a, begin, key-1);
	QuickSort3(a, key + 1, end);


}
//void QuickSort(int* a, int left, int right)
//{
//	
//}

// 快速排序 非递归实现
void QuickSortNone(int* a, int left, int right)
{
	//30, 15, 40, 28, 50, 10, 70
	ST st;
	STInit(&st);
	STPush(&st, right);
	STPush(&st, left);
	while (!STEmpty(&st))
	{
		int begin = STTop(&st);
		STPop(&st);
		int end = STTop(&st);
		STPop(&st);
		int key = PartSort3(a, begin, end);
		if (key + 1 < end)
		{
			STPush(&st, end);
			STPush(&st, key+1);

		}
		if (begin < key - 1)
		{
			STPush(&st, key-1);
			STPush(&st, begin);
		}
	
	}
	STDestroy(&st);



}
int main()
{
	srand((unsigned int)time(NULL));
	int a[] = { 5,-1,-3,4,6,7,8,2,5,-10,0 };
    //QuickSortNone(a,0,6);
	CountSort(a, sizeof(a) / sizeof(a[0]));
	//QuickSortNone(a, 0, sizeof(a) / sizeof(a[0]) - 1);
	//MergeSortNone(a, sizeof(a) / sizeof(a[0]));
	//CountSort(a, sizeof(a) / sizeof(a[0]));
	Print(a, sizeof(a) / sizeof(a[0]));

	//TestOP();
	//QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
	//Print(a, sizeof(a) / sizeof(a[0]));

	return 0;
}








//void CountSort(int* a, int n)
//{
//	int max = a[0], min = a[0];
//
//	for (int i = 0; i < n; i++)
//	{
//		if (max < a[i])
//		{
//			max = a[i];
//		}
//		if (min > a[i])
//		{
//			min = a[i];
//		}
//	}
//	int range = max - min + 1;
//	int* countA = (int*)calloc(sizeof(int) , range);
//	if (countA == NULL)
//	{
//		perror("calloc");
//		return;
//	}
//	for (int j = 0; j < n; j++)
//	{
//		countA[a[j] - min]++;
//	}
//	int r = 0;
//	for(int w = 0;w<range;w++)
//	{
//		while (countA[w]--)
//		{
//			a[r++] = w + min;
//		}
//	}
//	free(countA);
//	//
//	//1.统计每个数据出现的次数
//	//数据是0到9
//	//2.排序
//	//遍历一遍原数组O(N)
//	//遍历一边计数数组O(Max)
//	//总结:计数排序适合范围集中,且范围不大的整形数组排序
//	//不适合范围分散的数据
//
//
//
//
//}


//     
//1 2 3 6 4 5 

//1 2 3 4 5

//p  s  ?
//s->prior=p,s->next=p->next
//p->next->prior=s,s->prior=p;

//30 15 10 28 50 40 70

//int main()
//{
//	srand((unsigned int)time(NULL));
//	int n, i, m;
//	float b;
//	scanf("%d", &n);
//	m = 0;
//	for (i = 0; i < 10000; i++)
//	{
//		int s = 0; int c = 0;
//		while (c < 5)
//		{
//			int a = rand() % 20 + 1;
//			s = s + a;
//			c = c + 1;
//		}
//		if (s == n)
//		{
//			m = m + 1;
//		}
//		else if (s != n)
//		{
//			m = m;
//		}
//	}
//	b = 1.0 * m / (20 * 20 * 20 * 20 * 20);
//	printf("%.2f", b);
//}
